PyPI - django-cfg - Versions diffs - 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl - Mend

django-cfg 1.4.48py3-none-any.whl → 1.5.7py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of django-cfg might be problematic. Click here for more details.

Files changed (1022) hide show

django_cfg/apps/system/frontend/JWT_AUTO_INJECTION.md ADDED Viewed

@@ -0,0 +1,224 @@
+# JWT Auto-Injection для Next.js приложений
+## Обзор
+Django-CFG автоматически инжектирует JWT токены (`auth_token` и `refresh_token`) в `localStorage` для авторизованных пользователей при загрузке Next.js приложений через **NextJSStaticView**.
+## Как это работает
+### Автоматическая инжекция в Next.js apps (рекомендуется)
+**NextJSStaticView** автоматически инжектирует JWT токены во все HTML ответы для авторизованных пользователей.
+```python
+# urls.py
+from django_cfg.apps.frontend.views import AdminView
+urlpatterns = [
+    path('admin/', include('django_cfg.apps.frontend.urls')),  # JWT injection automatic
+]
+```
+При загрузке **любой страницы Next.js приложения**, если пользователь авторизован:
+1. View обслуживает статический файл Next.js
+2. Генерируются JWT токены (access + refresh)
+3. Токены автоматически инжектируются в `<head>` или `<body>` через `<script>` тег
+4. Токены сохраняются в `localStorage`
+**Преимущества:**
+- Работает только для Next.js приложений (безопасный scope)
+- Не нужно модифицировать templates
+- Централизованная логика в базовом view
+- Не влияет на другие HTML responses (Django admin, etc.)
+### Template Tags (для кастомных шаблонов)
+Если вы используете собственные Django шаблоны, можете использовать готовые template tags:
+#### 1. Полная автоматическая инжекция
+```django
+{% load django_cfg %}
+<!DOCTYPE html>
+<html>
+<head>
+    <title>My App</title>
+    {% inject_jwt_tokens_script %}  {# Автоматически инжектит оба токена #}
+</head>
+<body>
+    <!-- Your content -->
+</body>
+</html>
+```
+#### 2. Отдельные токены
+```django
+{% load django_cfg %}
+<script>
+    // Access token
+    const accessToken = '{% user_jwt_token %}';
+    // Refresh token
+    const refreshToken = '{% user_jwt_refresh_token %}';
+    // Manual storage
+    localStorage.setItem('auth_token', accessToken);
+    localStorage.setItem('refresh_token', refreshToken);
+</script>
+```
+## Использование в Next.js
+После инжекции токены доступны в вашем Next.js приложении:
+```typescript
+// В любом Next.js компоненте или API клиенте
+const accessToken = localStorage.getItem('auth_token');
+const refreshToken = localStorage.getItem('refresh_token');
+// Использование с API клиентом
+import { API } from './generated/cfg';
+const api = new API('http://localhost:8000', {
+  storage: {
+    getItem: (key) => localStorage.getItem(key),
+    setItem: (key, value) => localStorage.setItem(key, value),
+    removeItem: (key) => localStorage.removeItem(key),
+  }
+});
+```
+## Безопасность
+### Что инжектируется
+- `auth_token` - JWT access token (короткий срок жизни)
+- `refresh_token` - JWT refresh token (длинный срок жизни)
+### Когда инжектируется
+Токены генерируются **только** если:
+1. Пользователь **авторизован** через Django session
+2. Загружается **HTML файл** (не JS, CSS и т.д.)
+3. `rest_framework_simplejwt` установлен
+### Безопасность токенов
+- Токены генерируются **на лету** при каждом запросе
+- Access token имеет короткий срок жизни (настраивается в `JWTConfig`)
+- Refresh token позволяет получить новый access token без повторной авторизации
+- Токены хранятся только в `localStorage` на клиенте
+## Конфигурация JWT
+Настройка времени жизни токенов в `django_cfg`:
+```python
+from django_cfg.models.api import JWTConfig
+jwt_config = JWTConfig(
+    access_token_lifetime_hours=24,      # Access token на 24 часа
+    refresh_token_lifetime_days=30,      # Refresh token на 30 дней
+    rotate_refresh_tokens=True,          # Ротация refresh токенов
+    blacklist_after_rotation=True,       # Блэклист старых токенов
+)
+```
+## Отладка
+Проверьте в консоли браузера:
+```javascript
+// Проверить наличие токенов
+console.log('Access Token:', localStorage.getItem('auth_token'));
+console.log('Refresh Token:', localStorage.getItem('refresh_token'));
+// Сообщение об успешной инжекции
+// "JWT tokens injected successfully"
+```
+## Примеры
+### Пример 1: Автоматическая инжекция в Next.js приложении (рекомендуется)
+```python
+# urls.py - JWT injection работает автоматически
+urlpatterns = [
+    path('cfg/admin/', include('django_cfg.apps.frontend.urls')),  # Admin Panel with JWT
+]
+# views.py - создайте свой Next.js app view
+from django_cfg.apps.frontend.views import NextJSStaticView
+class MyAppView(NextJSStaticView):
+    """Custom Next.js app with automatic JWT injection."""
+    app_name = 'my_app'  # Serves from static/frontend/my_app/
+```
+При переходе на **любую страницу** Next.js приложения авторизованный пользователь автоматически получит JWT токены в localStorage.
+**⚠️ На /cfg/admin/auth токены НЕ инжектятся** - это страница логина, пользователь ещё не авторизован!
+### Пример 2: Кастомный шаблон с инжекцией
+```django
+{% load django_cfg %}
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Centrifugo Monitor</title>
+    {# Автоматическая инжекция JWT токенов #}
+    {% inject_jwt_tokens_script %}
+</head>
+<body>
+    <div id="root"></div>
+    <script src="/_next/static/chunks/main.js"></script>
+</body>
+</html>
+```
+## Требования
+- Django с включенной аутентификацией
+- `rest_framework_simplejwt` установлен
+- Пользователь авторизован через Django session
+## API Reference
+### Template Tags
+#### `{% user_jwt_token %}`
+Возвращает JWT access token для текущего пользователя.
+#### `{% user_jwt_refresh_token %}`
+Возвращает JWT refresh token для текущего пользователя.
+#### `{% inject_jwt_tokens_script %}`
+Генерирует полный `<script>` тег с автоматической инжекцией обоих токенов в localStorage.
+### View Classes
+#### `NextJSStaticView`
+Базовый view для обслуживания Next.js статических сборок с автоматической JWT инжекцией.
+**Features:**
+- Serves Next.js static export files
+- Automatically injects JWT tokens for authenticated users
+- Tokens injected into HTML responses only
+- Handles Next.js client-side routing (.html fallback)
+**Usage:**
+```python
+from django_cfg.apps.frontend.views import NextJSStaticView
+class MyAppView(NextJSStaticView):
+    app_name = 'my_app'  # Serves from static/frontend/my_app/
+```
+#### `AdminView`
+Специализированный view для Admin Panel (наследует `NextJSStaticView`).
+**Built-in JWT injection** - no additional configuration needed.

django_cfg/apps/system/frontend/__init__.py ADDED Viewed

@@ -0,0 +1,18 @@
+"""Django CFG Frontend App - Serves Next.js static builds."""
+default_app_config = 'django_cfg.apps.system.frontend.apps.FrontendConfig'
+# Convenience imports
+from .setup import (
+    setup_frontend_serving,
+    get_frontend_urls,
+    get_frontend_path,
+    is_frontend_built,
+)
+__all__ = [
+    'setup_frontend_serving',
+    'get_frontend_urls',
+    'get_frontend_path',
+    'is_frontend_built',
+]

django_cfg/apps/system/frontend/apps.py ADDED Viewed

@@ -0,0 +1,15 @@
+"""Django CFG Frontend App Configuration."""
+from django.apps import AppConfig
+class FrontendConfig(AppConfig):
+    """Configuration for Django CFG Frontend app."""
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.system.frontend'
+    verbose_name = 'Frontend Applications'
+    def ready(self):
+        """Initialize app when Django starts."""
+        pass

django_cfg/apps/system/frontend/setup.py ADDED Viewed

@@ -0,0 +1,105 @@
+"""
+Frontend App Setup Helpers
+Provides utilities to automatically configure Django to serve Next.js static builds.
+"""
+from pathlib import Path
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from django.conf import Settings
+def setup_frontend_serving(settings: 'Settings' = None) -> dict:
+    """
+    Configure Django to serve Next.js static builds.
+    This function returns configuration that should be added to Django settings.
+    Usage in settings.py:
+    ```python
+    from django_cfg.apps.system.frontend.setup import setup_frontend_serving
+    # Apply frontend configuration
+    frontend_config = setup_frontend_serving()
+    INSTALLED_APPS += frontend_config['INSTALLED_APPS']
+    ```
+    Args:
+        settings: Django settings module (optional)
+    Returns:
+        dict: Configuration to merge into settings
+    """
+    import django_cfg
+    config = {
+        'INSTALLED_APPS': [
+            'django_cfg.apps.system.frontend',
+        ],
+    }
+    return config
+def get_frontend_path(app_name: str = 'admin') -> Path:
+    """
+    Get the path to a frontend app's static build.
+    Args:
+        app_name: Name of the frontend app (e.g., 'admin')
+    Returns:
+        Path: Absolute path to the frontend build directory
+    Example:
+        >>> from django_cfg.apps.system.frontend.setup import get_frontend_path
+        >>> admin_path = get_frontend_path('admin')
+        >>> print(admin_path)
+        /path/to/django_cfg/static/frontend/admin
+    """
+    import django_cfg
+    return Path(django_cfg.__file__).parent / 'static' / 'frontend' / app_name
+def is_frontend_built(app_name: str = 'admin') -> bool:
+    """
+    Check if a frontend app has been built.
+    Args:
+        app_name: Name of the frontend app
+    Returns:
+        bool: True if the build exists, False otherwise
+    """
+    path = get_frontend_path(app_name)
+    index_html = path / 'index.html'
+    return index_html.exists()
+def get_frontend_urls():
+    """
+    Get URL patterns for frontend apps.
+    Usage in urls.py:
+    ```python
+    from django_cfg.apps.system.frontend.setup import get_frontend_urls
+    urlpatterns = [
+        # Your URLs here
+        ...
+    ]
+    # Add frontend URLs
+    urlpatterns += get_frontend_urls()
+    ```
+    Returns:
+        list: URL patterns for frontend apps
+    """
+    from django.urls import path, include
+    return [
+        path('', include('django_cfg.apps.system.frontend.urls', namespace='frontend')),
+    ]

django_cfg/apps/system/frontend/templates/frontend/404.html ADDED Viewed

@@ -0,0 +1,87 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>404: This page could not be found</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        html, body {
+            height: 100%;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
+            -webkit-font-smoothing: antialiased;
+            -moz-osx-font-smoothing: grayscale;
+        }
+        body {
+            color: #000;
+            background: #fff;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        .error {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100vh;
+        }
+        .error-content {
+            display: flex;
+            align-items: center;
+            gap: 20px;
+        }
+        .error-code {
+            font-size: 24px;
+            font-weight: 500;
+            padding-right: 23px;
+            border-right: 1px solid rgba(0, 0, 0, 0.3);
+            line-height: 49px;
+            height: 49px;
+        }
+        .error-message {
+            font-size: 14px;
+            font-weight: 400;
+            line-height: 49px;
+            height: 49px;
+        }
+        .error-message h2 {
+            font-size: 14px;
+            font-weight: 400;
+            display: inline;
+        }
+        /* Dark mode */
+        @media (prefers-color-scheme: dark) {
+            body {
+                color: #fff;
+                background: #000;
+            }
+            .error-code {
+                border-right-color: rgba(255, 255, 255, 0.3);
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="error">
+        <div class="error-content">
+            <div class="error-code">404</div>
+            <div class="error-message">
+                <h2>This page could not be found.</h2>
+            </div>
+        </div>
+    </div>
+</body>
+</html>

django_cfg/apps/system/frontend/test_routing.py ADDED Viewed

@@ -0,0 +1,134 @@
+"""
+Test script for SPA routing logic.
+Run this to verify that URL paths resolve correctly to static files.
+"""
+from pathlib import Path
+import django_cfg
+def test_resolve_spa_path():
+    """Test the SPA path resolution logic."""
+    # Simulate the base directory
+    base_dir = Path(django_cfg.__file__).parent / 'static' / 'frontend' / 'admin'
+    print(f"Base directory: {base_dir}")
+    print(f"Base directory exists: {base_dir.exists()}\n")
+    # Test cases
+    test_cases = [
+        # (input_path, expected_output_path, description)
+        ('', 'index.html', 'Root path'),
+        ('/', 'index.html', 'Root path with slash'),
+        ('private/centrifugo', 'private/centrifugo/index.html', 'Nested route without trailing slash'),
+        ('private/centrifugo/', 'private/centrifugo/index.html', 'Nested route with trailing slash'),
+        ('private', 'private.html', 'Single segment route'),
+        ('private/', 'private/index.html', 'Single segment with trailing slash'),
+        ('_next/static/chunks/app.js', '_next/static/chunks/app.js', 'Static asset (exact match)'),
+        ('favicon.ico', 'favicon.ico', 'Favicon (exact match)'),
+        ('unknown/route', 'index.html', 'Unknown route (SPA fallback)'),
+    ]
+    def resolve_spa_path(base_dir, path):
+        """
+        Exact copy of the view's _resolve_spa_path method.
+        This should match the logic in views.py exactly.
+        """
+        # Handle empty path (done in view before calling this method)
+        if not path or path == '/':
+            path = 'index.html'
+            return path
+        file_path = base_dir / path
+        path_normalized = path.rstrip('/')
+        # Strategy 1: Exact file match (for static assets like JS, CSS, images)
+        if file_path.exists() and file_path.is_file():
+            return path
+        # Strategy 2: Try path/index.html (most common for SPA routes)
+        index_in_dir = base_dir / path_normalized / 'index.html'
+        if index_in_dir.exists():
+            resolved_path = f"{path_normalized}/index.html"
+            return resolved_path
+        # Strategy 3: Try with trailing slash + index.html
+        if path.endswith('/'):
+            index_path = path + 'index.html'
+            if (base_dir / index_path).exists():
+                return index_path
+        # Strategy 4: Try path.html (Next.js static export behavior)
+        html_file = base_dir / (path_normalized + '.html')
+        if html_file.exists():
+            resolved_path = path_normalized + '.html'
+            return resolved_path
+        # Strategy 5: Check if it's a directory without index.html
+        if file_path.exists() and file_path.is_dir():
+            # Try index.html in that directory
+            index_in_existing_dir = file_path / 'index.html'
+            if index_in_existing_dir.exists():
+                resolved_path = f"{path_normalized}/index.html"
+                return resolved_path
+        # Strategy 6: SPA fallback - serve root index.html
+        # This allows client-side routing to handle unknown routes
+        root_index = base_dir / 'index.html'
+        if root_index.exists():
+            return 'index.html'
+        # Strategy 7: Nothing found - return original path (will 404)
+        return path
+    print("=" * 80)
+    print("SPA ROUTING TEST RESULTS")
+    print("=" * 80)
+    passed = 0
+    failed = 0
+    for input_path, expected, description in test_cases:
+        result = resolve_spa_path(base_dir, input_path)
+        # Check if file exists
+        resolved_file = base_dir / result
+        file_exists = resolved_file.exists() and resolved_file.is_file()
+        # Determine test status
+        if result == expected:
+            status = "✅ PASS"
+            passed += 1
+        else:
+            status = "❌ FAIL"
+            failed += 1
+        print(f"\n{status} - {description}")
+        print(f"  Input:    '{input_path}'")
+        print(f"  Expected: '{expected}'")
+        print(f"  Got:      '{result}'")
+        print(f"  File exists: {file_exists}")
+        if result != expected:
+            print(f"  ⚠️  Mismatch detected!")
+    print("\n" + "=" * 80)
+    print(f"TEST SUMMARY: {passed} passed, {failed} failed out of {len(test_cases)} tests")
+    print("=" * 80)
+    # Additional info
+    print("\n📁 File structure check:")
+    if base_dir.exists():
+        print(f"  - index.html: {(base_dir / 'index.html').exists()}")
+        print(f"  - private.html: {(base_dir / 'private.html').exists()}")
+        print(f"  - private/index.html: {(base_dir / 'private' / 'index.html').exists()}")
+        print(f"  - private/centrifugo/index.html: {(base_dir / 'private' / 'centrifugo' / 'index.html').exists()}")
+    else:
+        print(f"  ⚠️  Base directory does not exist!")
+if __name__ == '__main__':
+    test_resolve_spa_path()

django_cfg/apps/system/frontend/urls.py ADDED Viewed

@@ -0,0 +1,12 @@
+"""URL Configuration for Frontend Apps."""
+from django.urls import re_path
+from .views import AdminView
+app_name = 'frontend'
+urlpatterns = [
+    # Next.js Admin Panel - catch all routes for client-side routing
+    re_path(r'^(?P<path>.*)$', AdminView.as_view(), name='admin'),
+]

django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

Potentially problematic release.

django-cfg 1.4.48py3-none-any.whl → 1.5.7py3-none-any.whl