django-vite-rolling 0.1.0__tar.gz

django_vite_rolling-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,37 @@
+name: release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # setuptools-scm needs full history for version
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build
+        run: |
+          python -m pip install -U pip build
+          python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # required for PyPI trusted publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

django_vite_rolling-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,29 @@
+name: test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.11", "3.12", "3.13"]
+        django: ["4.2", "5.0", "5.1"]
+        exclude:
+          - python: "3.13"
+            django: "4.2"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Install
+        run: |
+          python -m pip install -U pip
+          python -m pip install "Django~=${{ matrix.django }}.0" -e ".[test]"
+      - name: Run tests
+        run: pytest -v

django_vite_rolling-0.1.0/.gitignore

@@ -0,0 +1,32 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+.eggs/
+build/
+dist/
+.tox/
+.nox/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Virtualenvs
+.venv/
+venv/
+env/
+
+# Editors
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store

django_vite_rolling-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wedgworth's, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_vite_rolling-0.1.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: django-vite-rolling
+Version: 0.1.0
+Summary: Lean Django + Vite integration with rolling-deploy-safe manifest caching.
+Author-email: Patrick Altman <patrick@wedgworth.com>
+License: MIT
+Project-URL: Homepage, https://github.com/wedgworth/django-vite-rolling
+Project-URL: Issues, https://github.com/wedgworth/django-vite-rolling/issues
+Project-URL: Source, https://github.com/wedgworth/django-vite-rolling
+Keywords: django,vite,manifest,rolling-deploy
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Requires-Dist: django-redis>=5.0
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-django>=4; extra == "test"
+Requires-Dist: fakeredis>=2; extra == "test"
+Dynamic: license-file
+
+# django-vite-rolling
+
+A lean Django + Vite integration with rolling-deploy-safe manifest caching.
+
+Roughly 100 lines of code. No React Refresh, no polyfills, no legacy bundle handling — just `{% vite_scripts %}`, `{% vite_styles %}`, and a management command that keeps Vite manifest caches consistent across rolling deploys.
+
+## Why this exists
+
+Most Django + Vite integrations cache one manifest globally. On a rolling deploy, both the old and new app versions can serve requests simultaneously, each needing their own manifest. This package caches manifests under versioned Redis keys (`vite_manifest:<RELEASE_VERSION>`) and provides a management command to prune stale versions during deploys.
+
+If you don't need versioned/rolling-deploy support, you probably want [`django-vite`](https://github.com/MrBin99/django-vite) instead.
+
+## Install
+
+```bash
+pip install django-vite-rolling
+```
+
+Add to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "django_vite_rolling",
+]
+```
+
+Requires `django-redis` configured as your default cache backend.
+
+## Configure
+
+```python
+VITE = {
+    "manifest_path": BASE_DIR / "static" / ".vite" / "manifest.json",
+    "cache": not DEBUG,
+}
+```
+
+### All settings
+
+| Key | Default | Description |
+|---|---|---|
+| `manifest_path` | *(required)* | Path to Vite's `manifest.json` |
+| `cache` | `True` | Whether to cache the loaded manifest in Redis (set `False` in dev) |
+| `cache_key_prefix` | `"vite_manifest"` | Redis key prefix; full key is `<prefix>:<RELEASE_VERSION>` |
+| `dev_server_host` | `None` | Dev server host. `None` → derive from request `Host` header (fallback `localhost`) |
+| `dev_server_port` | `3001` | Dev server port |
+| `dev_server_static_path` | `"/static"` | Path prefix Vite serves from |
+| `versions_to_keep` | `5` | How many recent release versions to retain manifests for |
+| `version_setting` | `"RELEASE_VERSION"` | Name of the Django setting holding the current release identifier |
+| `versions_redis_key` | `"recent-manifest-versions"` | Redis list key tracking recent versions |
+| `redis_alias` | `"default"` | django-redis alias to use |
+
+## Usage
+
+In your base template:
+
+```html
+{% load vite %}
+<!DOCTYPE html>
+<html>
+  <head>
+    {% vite_styles "src/main.ts" %}
+  </head>
+  <body>
+    {% vite_scripts "src/main.ts" %}
+  </body>
+</html>
+```
+
+In `DEBUG` mode the tags inject Vite's HMR client and module URLs pointing at the dev server. In production they resolve the named entries through the manifest, including recursively-imported chunks and their CSS.
+
+## Post-deploy
+
+Run after each deploy (e.g., in a release-phase / post-deploy hook):
+
+```bash
+python manage.py refresh_vite_manifest
+```
+
+This:
+1. Records `RELEASE_VERSION` in a Redis list of recent versions (truncated to `versions_to_keep`).
+2. Scans for `vite_manifest:*` keys whose suffix is not in the recent list and deletes them.
+3. Loads the current manifest and caches it under `vite_manifest:<RELEASE_VERSION>`.
+
+If `RELEASE_VERSION` is empty, the command caches the manifest under the bare prefix and skips cleanup.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT

django_vite_rolling-0.1.0/README.md

@@ -0,0 +1,97 @@
+# django-vite-rolling
+
+A lean Django + Vite integration with rolling-deploy-safe manifest caching.
+
+Roughly 100 lines of code. No React Refresh, no polyfills, no legacy bundle handling — just `{% vite_scripts %}`, `{% vite_styles %}`, and a management command that keeps Vite manifest caches consistent across rolling deploys.
+
+## Why this exists
+
+Most Django + Vite integrations cache one manifest globally. On a rolling deploy, both the old and new app versions can serve requests simultaneously, each needing their own manifest. This package caches manifests under versioned Redis keys (`vite_manifest:<RELEASE_VERSION>`) and provides a management command to prune stale versions during deploys.
+
+If you don't need versioned/rolling-deploy support, you probably want [`django-vite`](https://github.com/MrBin99/django-vite) instead.
+
+## Install
+
+```bash
+pip install django-vite-rolling
+```
+
+Add to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "django_vite_rolling",
+]
+```
+
+Requires `django-redis` configured as your default cache backend.
+
+## Configure
+
+```python
+VITE = {
+    "manifest_path": BASE_DIR / "static" / ".vite" / "manifest.json",
+    "cache": not DEBUG,
+}
+```
+
+### All settings
+
+| Key | Default | Description |
+|---|---|---|
+| `manifest_path` | *(required)* | Path to Vite's `manifest.json` |
+| `cache` | `True` | Whether to cache the loaded manifest in Redis (set `False` in dev) |
+| `cache_key_prefix` | `"vite_manifest"` | Redis key prefix; full key is `<prefix>:<RELEASE_VERSION>` |
+| `dev_server_host` | `None` | Dev server host. `None` → derive from request `Host` header (fallback `localhost`) |
+| `dev_server_port` | `3001` | Dev server port |
+| `dev_server_static_path` | `"/static"` | Path prefix Vite serves from |
+| `versions_to_keep` | `5` | How many recent release versions to retain manifests for |
+| `version_setting` | `"RELEASE_VERSION"` | Name of the Django setting holding the current release identifier |
+| `versions_redis_key` | `"recent-manifest-versions"` | Redis list key tracking recent versions |
+| `redis_alias` | `"default"` | django-redis alias to use |
+
+## Usage
+
+In your base template:
+
+```html
+{% load vite %}
+<!DOCTYPE html>
+<html>
+  <head>
+    {% vite_styles "src/main.ts" %}
+  </head>
+  <body>
+    {% vite_scripts "src/main.ts" %}
+  </body>
+</html>
+```
+
+In `DEBUG` mode the tags inject Vite's HMR client and module URLs pointing at the dev server. In production they resolve the named entries through the manifest, including recursively-imported chunks and their CSS.
+
+## Post-deploy
+
+Run after each deploy (e.g., in a release-phase / post-deploy hook):
+
+```bash
+python manage.py refresh_vite_manifest
+```
+
+This:
+1. Records `RELEASE_VERSION` in a Redis list of recent versions (truncated to `versions_to_keep`).
+2. Scans for `vite_manifest:*` keys whose suffix is not in the recent list and deletes them.
+3. Loads the current manifest and caches it under `vite_manifest:<RELEASE_VERSION>`.
+
+If `RELEASE_VERSION` is empty, the command caches the manifest under the bare prefix and skips cleanup.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT

django_vite_rolling-0.1.0/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=68", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-vite-rolling"
+description = "Lean Django + Vite integration with rolling-deploy-safe manifest caching."
+readme = "README.md"
+authors = [{ name = "Patrick Altman", email = "patrick@wedgworth.com" }]
+license = { text = "MIT" }
+requires-python = ">=3.11"
+keywords = ["django", "vite", "manifest", "rolling-deploy"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Framework :: Django",
+    "Framework :: Django :: 4.2",
+    "Framework :: Django :: 5.0",
+    "Framework :: Django :: 5.1",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = [
+    "django>=4.2",
+    "django-redis>=5.0",
+]
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://github.com/wedgworth/django-vite-rolling"
+Issues = "https://github.com/wedgworth/django-vite-rolling/issues"
+Source = "https://github.com/wedgworth/django-vite-rolling"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7",
+    "pytest-django>=4",
+    "fakeredis>=2",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools_scm]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "tests.settings"
+python_files = ["test_*.py"]
+pythonpath = ["."]
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W", "UP"]

django_vite_rolling-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

django_vite_rolling-0.1.0/src/django_vite_rolling/__init__.py

@@ -0,0 +1 @@
+default_app_config = "django_vite_rolling.apps.DjangoViteRollingConfig"

django_vite_rolling-0.1.0/src/django_vite_rolling/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DjangoViteRollingConfig(AppConfig):
+    name = "django_vite_rolling"
+    verbose_name = "Django Vite Rolling"

django_vite_rolling-0.1.0/src/django_vite_rolling/conf.py

@@ -0,0 +1,30 @@
+from django.conf import settings
+
+
+DEFAULTS = {
+    "manifest_path": None,
+    "cache": True,
+    "cache_key_prefix": "vite_manifest",
+    "dev_server_host": None,
+    "dev_server_port": 3001,
+    "dev_server_static_path": "/static",
+    "versions_to_keep": 5,
+    "version_setting": "RELEASE_VERSION",
+    "versions_redis_key": "recent-manifest-versions",
+    "redis_alias": "default",
+}
+
+
+def get_setting(key: str):
+    user_settings = getattr(settings, "VITE", {})
+    return user_settings.get(key, DEFAULTS[key])
+
+
+def get_release_version() -> str:
+    return getattr(settings, get_setting("version_setting"), "") or ""
+
+
+def get_cache_key() -> str:
+    prefix = get_setting("cache_key_prefix")
+    version = get_release_version()
+    return f"{prefix}:{version}" if version else prefix

django_vite_rolling-0.1.0/src/django_vite_rolling/management/commands/refresh_vite_manifest.py

@@ -0,0 +1,57 @@
+from django.core.management import BaseCommand
+from django_redis import get_redis_connection
+from redis.exceptions import RedisError
+
+from django_vite_rolling.conf import get_release_version, get_setting
+from django_vite_rolling.manifest import set_manifest
+
+
+class Command(BaseCommand):
+    help = "Refresh the Vite manifest cache and prune stale versions for rolling deploys."
+
+    def handle(self, *args, **options):
+        version = get_release_version()
+
+        if not version:
+            self.stdout.write(self.style.WARNING(
+                f"{get_setting('version_setting')} is empty; caching manifest without versioned cleanup."
+            ))
+            set_manifest()
+            self.stdout.write(self.style.SUCCESS("Vite manifest cached."))
+            return
+
+        versions_to_keep = get_setting("versions_to_keep")
+        prefix_match = f"{get_setting('cache_key_prefix')}:*"
+        versions_key = get_setting("versions_redis_key")
+        redis_alias = get_setting("redis_alias")
+
+        try:
+            client = get_redis_connection(redis_alias)
+            client.lpush(versions_key, version.encode("utf-8"))
+            if versions_to_keep:
+                client.ltrim(versions_key, 0, versions_to_keep - 1)
+
+            recent = {v.decode("utf-8") for v in client.lrange(versions_key, 0, -1)}
+            self.stdout.write(f"Recent versions: {sorted(recent)}")
+
+            deleted = 0
+            cursor = 0
+            while True:
+                cursor, keys = client.scan(cursor=cursor, match=prefix_match, count=100)
+                for key in keys:
+                    key_str = key.decode("utf-8")
+                    if not any(key_str.endswith(f":{v}") for v in recent):
+                        client.delete(key)
+                        deleted += 1
+                        self.stdout.write(f"Deleted stale manifest key: {key_str}")
+                if cursor == 0:
+                    break
+
+            self.stdout.write(self.style.SUCCESS(
+                f"Added '{version}' to recent versions; deleted {deleted} stale key(s)."
+            ))
+
+            set_manifest()
+            self.stdout.write(self.style.SUCCESS("Vite manifest cached."))
+        except RedisError as e:
+            self.stdout.write(self.style.ERROR(f"Redis error: {e}"))

django_vite_rolling-0.1.0/src/django_vite_rolling/manifest.py

@@ -0,0 +1,32 @@
+import json
+import typing
+
+from django.core.cache import cache
+
+from django_vite_rolling.conf import get_cache_key, get_setting
+
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    ChunkType = typing.TypedDict(
+        "ChunkType",
+        {"file": str, "css": list[str], "imports": list[str]},
+        total=False,
+    )
+    ManifestType = typing.Mapping[str, ChunkType]
+
+
+def set_manifest() -> "ManifestType":
+    manifest_path = get_setting("manifest_path")
+    if not manifest_path:
+        raise RuntimeError("VITE['manifest_path'] is not configured")
+    with open(manifest_path) as fp:
+        manifest: ManifestType = json.load(fp)
+    cache.set(get_cache_key(), manifest, None)
+    return manifest
+
+
+def get_manifest() -> "ManifestType":
+    if cached := cache.get(get_cache_key()):
+        if get_setting("cache"):
+            return cached
+    return set_manifest()

django_vite_rolling-0.1.0/src/django_vite_rolling/templatetags/vite.py

@@ -0,0 +1,75 @@
+import re
+import typing
+
+from django import template
+from django.conf import settings
+from django.templatetags.static import static
+from django.utils.safestring import mark_safe
+
+from django_vite_rolling.conf import get_setting
+from django_vite_rolling.manifest import get_manifest
+
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from django.utils.safestring import SafeString
+
+
+register = template.Library()
+
+
+def _is_absolute_url(url: str) -> bool:
+    return re.match("^https?://", url) is not None
+
+
+def _dev_server_root(request=None) -> str:
+    host = get_setting("dev_server_host")
+    if host is None:
+        host = "localhost"
+        if request is not None:
+            host = request.get_host().split(":")[0]
+    port = get_setting("dev_server_port")
+    static_path = get_setting("dev_server_static_path")
+    return f"http://{host}:{port}{static_path}"
+
+
+def vite_manifest(entries_names: typing.Sequence[str], request=None) -> tuple[list[str], list[str]]:
+    if settings.DEBUG:
+        dev_root = _dev_server_root(request)
+        scripts = [f"{dev_root}/@vite/client"] + [f"{dev_root}/{name}" for name in entries_names]
+        return scripts, []
+
+    manifest = get_manifest()
+    seen: set[str] = set()
+
+    def _process(names: typing.Sequence[str]) -> tuple[list[str], list[str]]:
+        scripts: list[str] = []
+        styles: list[str] = []
+        for name in names:
+            if name in seen:
+                continue
+            chunk = manifest[name]
+            import_scripts, import_styles = _process(chunk.get("imports", []))
+            scripts.extend(import_scripts)
+            styles.extend(import_styles)
+            scripts.append(chunk["file"])
+            styles.extend(chunk.get("css", []))
+            seen.add(name)
+        return scripts, styles
+
+    return _process(entries_names)
+
+
+@register.simple_tag(name="vite_styles", takes_context=True)
+def vite_styles(context, *entries_names: str) -> "SafeString":
+    request = context.get("request")
+    _, styles = vite_manifest(entries_names, request=request)
+    hrefs = (href if _is_absolute_url(href) else static(href) for href in styles)
+    return mark_safe("\n".join(f'<link rel="stylesheet" href="{href}" />' for href in hrefs))  # nosec
+
+
+@register.simple_tag(name="vite_scripts", takes_context=True)
+def vite_scripts(context, *entries_names: str) -> "SafeString":
+    request = context.get("request")
+    scripts, _ = vite_manifest(entries_names, request=request)
+    srcs = (src if _is_absolute_url(src) else static(src) for src in scripts)
+    return mark_safe("\n".join(f'<script type="module" src="{src}"></script>' for src in srcs))  # nosec

django_vite_rolling-0.1.0/src/django_vite_rolling.egg-info/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: django-vite-rolling
+Version: 0.1.0
+Summary: Lean Django + Vite integration with rolling-deploy-safe manifest caching.
+Author-email: Patrick Altman <patrick@wedgworth.com>
+License: MIT
+Project-URL: Homepage, https://github.com/wedgworth/django-vite-rolling
+Project-URL: Issues, https://github.com/wedgworth/django-vite-rolling/issues
+Project-URL: Source, https://github.com/wedgworth/django-vite-rolling
+Keywords: django,vite,manifest,rolling-deploy
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Requires-Dist: django-redis>=5.0
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-django>=4; extra == "test"
+Requires-Dist: fakeredis>=2; extra == "test"
+Dynamic: license-file
+
+# django-vite-rolling
+
+A lean Django + Vite integration with rolling-deploy-safe manifest caching.
+
+Roughly 100 lines of code. No React Refresh, no polyfills, no legacy bundle handling — just `{% vite_scripts %}`, `{% vite_styles %}`, and a management command that keeps Vite manifest caches consistent across rolling deploys.
+
+## Why this exists
+
+Most Django + Vite integrations cache one manifest globally. On a rolling deploy, both the old and new app versions can serve requests simultaneously, each needing their own manifest. This package caches manifests under versioned Redis keys (`vite_manifest:<RELEASE_VERSION>`) and provides a management command to prune stale versions during deploys.
+
+If you don't need versioned/rolling-deploy support, you probably want [`django-vite`](https://github.com/MrBin99/django-vite) instead.
+
+## Install
+
+```bash
+pip install django-vite-rolling
+```
+
+Add to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "django_vite_rolling",
+]
+```
+
+Requires `django-redis` configured as your default cache backend.
+
+## Configure
+
+```python
+VITE = {
+    "manifest_path": BASE_DIR / "static" / ".vite" / "manifest.json",
+    "cache": not DEBUG,
+}
+```
+
+### All settings
+
+| Key | Default | Description |
+|---|---|---|
+| `manifest_path` | *(required)* | Path to Vite's `manifest.json` |
+| `cache` | `True` | Whether to cache the loaded manifest in Redis (set `False` in dev) |
+| `cache_key_prefix` | `"vite_manifest"` | Redis key prefix; full key is `<prefix>:<RELEASE_VERSION>` |
+| `dev_server_host` | `None` | Dev server host. `None` → derive from request `Host` header (fallback `localhost`) |
+| `dev_server_port` | `3001` | Dev server port |
+| `dev_server_static_path` | `"/static"` | Path prefix Vite serves from |
+| `versions_to_keep` | `5` | How many recent release versions to retain manifests for |
+| `version_setting` | `"RELEASE_VERSION"` | Name of the Django setting holding the current release identifier |
+| `versions_redis_key` | `"recent-manifest-versions"` | Redis list key tracking recent versions |
+| `redis_alias` | `"default"` | django-redis alias to use |
+
+## Usage
+
+In your base template:
+
+```html
+{% load vite %}
+<!DOCTYPE html>
+<html>
+  <head>
+    {% vite_styles "src/main.ts" %}
+  </head>
+  <body>
+    {% vite_scripts "src/main.ts" %}
+  </body>
+</html>
+```
+
+In `DEBUG` mode the tags inject Vite's HMR client and module URLs pointing at the dev server. In production they resolve the named entries through the manifest, including recursively-imported chunks and their CSS.
+
+## Post-deploy
+
+Run after each deploy (e.g., in a release-phase / post-deploy hook):
+
+```bash
+python manage.py refresh_vite_manifest
+```
+
+This:
+1. Records `RELEASE_VERSION` in a Redis list of recent versions (truncated to `versions_to_keep`).
+2. Scans for `vite_manifest:*` keys whose suffix is not in the recent list and deletes them.
+3. Loads the current manifest and caches it under `vite_manifest:<RELEASE_VERSION>`.
+
+If `RELEASE_VERSION` is empty, the command caches the manifest under the bare prefix and skips cleanup.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT

django_vite_rolling-0.1.0/src/django_vite_rolling.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+.gitignore
+LICENSE
+README.md
+pyproject.toml
+.github/workflows/release.yml
+.github/workflows/test.yml
+src/django_vite_rolling/__init__.py
+src/django_vite_rolling/apps.py
+src/django_vite_rolling/conf.py
+src/django_vite_rolling/manifest.py
+src/django_vite_rolling.egg-info/PKG-INFO
+src/django_vite_rolling.egg-info/SOURCES.txt
+src/django_vite_rolling.egg-info/dependency_links.txt
+src/django_vite_rolling.egg-info/requires.txt
+src/django_vite_rolling.egg-info/top_level.txt
+src/django_vite_rolling/management/__init__.py
+src/django_vite_rolling/management/commands/__init__.py
+src/django_vite_rolling/management/commands/refresh_vite_manifest.py
+src/django_vite_rolling/templatetags/__init__.py
+src/django_vite_rolling/templatetags/vite.py
+tests/__init__.py
+tests/conftest.py
+tests/settings.py
+tests/test_conf.py
+tests/test_manifest.py
+tests/test_refresh_command.py
+tests/test_templatetags.py

django_vite_rolling-0.1.0/src/django_vite_rolling.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_vite_rolling-0.1.0/src/django_vite_rolling.egg-info/requires.txt

@@ -0,0 +1,7 @@
+django>=4.2
+django-redis>=5.0
+
+[test]
+pytest>=7
+pytest-django>=4
+fakeredis>=2

django_vite_rolling-0.1.0/src/django_vite_rolling.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_vite_rolling

django_vite_rolling-0.1.0/tests/conftest.py

@@ -0,0 +1,31 @@
+import json
+
+import pytest
+from django.core.cache import cache
+
+
+SAMPLE_MANIFEST = {
+    "src/main.ts": {
+        "file": "assets/main-abc123.js",
+        "css": ["assets/main-abc123.css"],
+        "imports": ["_shared.js"],
+    },
+    "_shared.js": {
+        "file": "assets/shared-def456.js",
+        "css": ["assets/shared-def456.css"],
+    },
+}
+
+
+@pytest.fixture
+def manifest_file(tmp_path):
+    path = tmp_path / "manifest.json"
+    path.write_text(json.dumps(SAMPLE_MANIFEST))
+    return path
+
+
+@pytest.fixture(autouse=True)
+def clear_cache():
+    cache.clear()
+    yield
+    cache.clear()

django_vite_rolling-0.1.0/tests/settings.py

@@ -0,0 +1,43 @@
+SECRET_KEY = "test"
+DEBUG = False
+ALLOWED_HOSTS = ["*"]
+
+INSTALLED_APPS = [
+    "django.contrib.contenttypes",
+    "django.contrib.auth",
+    "django.contrib.staticfiles",
+    "django_vite_rolling",
+]
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": ":memory:",
+    }
+}
+
+CACHES = {
+    "default": {
+        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+    },
+}
+
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [],
+        },
+    },
+]
+
+STATIC_URL = "/static/"
+USE_TZ = True
+
+RELEASE_VERSION = "test-version"
+
+VITE = {
+    "manifest_path": None,
+    "cache": True,
+}

django_vite_rolling-0.1.0/tests/test_conf.py

@@ -0,0 +1,37 @@
+from django.test import override_settings
+
+from django_vite_rolling.conf import get_cache_key, get_release_version, get_setting
+
+
+def test_get_setting_returns_default_when_not_configured():
+    assert get_setting("cache_key_prefix") == "vite_manifest"
+
+
+@override_settings(VITE={"cache_key_prefix": "custom_prefix"})
+def test_get_setting_returns_user_override():
+    assert get_setting("cache_key_prefix") == "custom_prefix"
+
+
+@override_settings(RELEASE_VERSION="abc123")
+def test_get_release_version_reads_default_setting():
+    assert get_release_version() == "abc123"
+
+
+@override_settings(RELEASE_VERSION="")
+def test_get_release_version_blank_is_empty():
+    assert get_release_version() == ""
+
+
+@override_settings(RELEASE_VERSION="v1.2.3")
+def test_get_cache_key_with_version():
+    assert get_cache_key() == "vite_manifest:v1.2.3"
+
+
+@override_settings(RELEASE_VERSION="")
+def test_get_cache_key_without_version_falls_back_to_prefix():
+    assert get_cache_key() == "vite_manifest"
+
+
+@override_settings(MY_VERSION="x", VITE={"version_setting": "MY_VERSION"})
+def test_version_setting_is_configurable():
+    assert get_release_version() == "x"

django_vite_rolling-0.1.0/tests/test_manifest.py

@@ -0,0 +1,35 @@
+import pytest
+from django.core.cache import cache
+from django.test import override_settings
+
+from django_vite_rolling.manifest import get_manifest, set_manifest
+
+
+def test_set_manifest_loads_from_file_and_caches(manifest_file):
+    with override_settings(VITE={"manifest_path": str(manifest_file)}, RELEASE_VERSION="v1"):
+        result = set_manifest()
+        assert "src/main.ts" in result
+        assert cache.get("vite_manifest:v1") == result
+
+
+def test_set_manifest_raises_when_path_unconfigured():
+    with override_settings(VITE={"manifest_path": None}):
+        with pytest.raises(RuntimeError, match="manifest_path"):
+            set_manifest()
+
+
+def test_get_manifest_returns_cached_when_cache_enabled(manifest_file):
+    with override_settings(VITE={"manifest_path": str(manifest_file), "cache": True}, RELEASE_VERSION="v1"):
+        first = set_manifest()
+        cache.set("vite_manifest:v1", {"sentinel": {"file": "x"}}, None)
+        second = get_manifest()
+        assert second == {"sentinel": {"file": "x"}}
+        assert second != first
+
+
+def test_get_manifest_re_reads_when_cache_disabled(manifest_file):
+    with override_settings(VITE={"manifest_path": str(manifest_file), "cache": False}, RELEASE_VERSION="v1"):
+        set_manifest()
+        cache.set("vite_manifest:v1", {"sentinel": {"file": "x"}}, None)
+        result = get_manifest()
+        assert "src/main.ts" in result

django_vite_rolling-0.1.0/tests/test_refresh_command.py

@@ -0,0 +1,67 @@
+from io import StringIO
+from unittest.mock import patch
+
+import fakeredis
+from django.core.management import call_command
+from django.test import override_settings
+
+
+def _fake_client():
+    return fakeredis.FakeRedis()
+
+
+def test_command_warns_when_release_version_empty(manifest_file):
+    out = StringIO()
+    with override_settings(RELEASE_VERSION="", VITE={"manifest_path": str(manifest_file)}):
+        call_command("refresh_vite_manifest", stdout=out)
+    output = out.getvalue()
+    assert "RELEASE_VERSION is empty" in output
+    assert "Vite manifest cached" in output
+
+
+def test_command_records_version_and_caches_manifest(manifest_file):
+    client = _fake_client()
+    out = StringIO()
+    with override_settings(RELEASE_VERSION="v1", VITE={"manifest_path": str(manifest_file)}):
+        with patch("django_vite_rolling.management.commands.refresh_vite_manifest.get_redis_connection",
+                   return_value=client):
+            call_command("refresh_vite_manifest", stdout=out)
+    versions = [v.decode("utf-8") for v in client.lrange("recent-manifest-versions", 0, -1)]
+    assert versions == ["v1"]
+    assert "Vite manifest cached" in out.getvalue()
+
+
+def test_command_deletes_stale_versioned_keys(manifest_file):
+    client = _fake_client()
+    client.set("vite_manifest:old1", b"stale")
+    client.set("vite_manifest:old2", b"stale")
+    client.set("vite_manifest:keep", b"current")
+    client.lpush("recent-manifest-versions", b"keep")
+
+    out = StringIO()
+    with override_settings(RELEASE_VERSION="new", VITE={"manifest_path": str(manifest_file), "versions_to_keep": 2}):
+        with patch("django_vite_rolling.management.commands.refresh_vite_manifest.get_redis_connection",
+                   return_value=client):
+            call_command("refresh_vite_manifest", stdout=out)
+
+    # "new" and "keep" should both be retained (versions_to_keep=2)
+    versions = {v.decode("utf-8") for v in client.lrange("recent-manifest-versions", 0, -1)}
+    assert versions == {"new", "keep"}
+    assert client.get("vite_manifest:old1") is None
+    assert client.get("vite_manifest:old2") is None
+    assert client.get("vite_manifest:keep") == b"current"
+
+
+def test_command_trims_to_versions_to_keep(manifest_file):
+    client = _fake_client()
+    for v in ["a", "b", "c", "d", "e"]:
+        client.lpush("recent-manifest-versions", v.encode("utf-8"))
+
+    with override_settings(RELEASE_VERSION="f", VITE={"manifest_path": str(manifest_file), "versions_to_keep": 3}):
+        with patch("django_vite_rolling.management.commands.refresh_vite_manifest.get_redis_connection",
+                   return_value=client):
+            call_command("refresh_vite_manifest", stdout=StringIO())
+
+    versions = [v.decode("utf-8") for v in client.lrange("recent-manifest-versions", 0, -1)]
+    assert len(versions) == 3
+    assert versions[0] == "f"

django_vite_rolling-0.1.0/tests/test_templatetags.py

@@ -0,0 +1,55 @@
+from django.template import Context, Template
+from django.test import RequestFactory, override_settings
+
+
+def _render(template_source: str, request=None) -> str:
+    template = Template(template_source)
+    return template.render(Context({"request": request}))
+
+
+@override_settings(DEBUG=True)
+def test_dev_mode_emits_vite_client_and_entry():
+    result = _render('{% load vite %}{% vite_scripts "src/main.ts" %}')
+    assert "@vite/client" in result
+    assert "localhost:3001/static/src/main.ts" in result
+
+
+@override_settings(DEBUG=True)
+def test_dev_mode_uses_request_host():
+    rf = RequestFactory()
+    request = rf.get("/", HTTP_HOST="dev.box:8000")
+    result = _render('{% load vite %}{% vite_scripts "src/main.ts" %}', request=request)
+    assert "dev.box:3001" in result
+
+
+@override_settings(DEBUG=True, VITE={"dev_server_host": "fixed.host", "dev_server_port": 5173})
+def test_dev_mode_respects_configured_host_and_port():
+    result = _render('{% load vite %}{% vite_scripts "src/main.ts" %}')
+    assert "fixed.host:5173" in result
+
+
+def test_prod_mode_resolves_entry_and_imports(manifest_file):
+    with override_settings(DEBUG=False, VITE={"manifest_path": str(manifest_file)}, RELEASE_VERSION="v1"):
+        scripts = _render('{% load vite %}{% vite_scripts "src/main.ts" %}')
+        # Imported chunk should come before the entry chunk
+        assert scripts.index("shared-def456.js") < scripts.index("main-abc123.js")
+
+
+def test_prod_mode_emits_styles(manifest_file):
+    with override_settings(DEBUG=False, VITE={"manifest_path": str(manifest_file)}, RELEASE_VERSION="v1"):
+        styles = _render('{% load vite %}{% vite_styles "src/main.ts" %}')
+        assert "main-abc123.css" in styles
+        assert "shared-def456.css" in styles
+        assert 'rel="stylesheet"' in styles
+
+
+def test_prod_mode_passes_through_absolute_urls(tmp_path):
+    import json
+    path = tmp_path / "manifest.json"
+    path.write_text(json.dumps({
+        "src/main.ts": {"file": "https://cdn.example.com/main.js", "css": ["https://cdn.example.com/main.css"]},
+    }))
+    with override_settings(DEBUG=False, VITE={"manifest_path": str(path)}, RELEASE_VERSION="v1"):
+        scripts = _render('{% load vite %}{% vite_scripts "src/main.ts" %}')
+        assert "https://cdn.example.com/main.js" in scripts
+        assert "/static/https" not in scripts