django-stack 0.0.1__tar.gz → 0.2.0__tar.gz

django_stack-0.2.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.5
+Name: django-stack
+Version: 0.2.0
+Summary: The backend glue of DjangoStack: settings from environment variables, API defaults, health checks and system checks.
+Project-URL: Homepage, https://github.com/dwarsbit/django-stack
+Project-URL: Source, https://github.com/dwarsbit/django-stack/tree/main/python/django-stack
+Project-URL: Issues, https://github.com/dwarsbit/django-stack/issues
+Author-email: Leon van der Grient <leon@dwarsbit.nl>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cms,django,django-content-studio,django-headless,headless,jamstack
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Requires-Dist: django-content-studio[huey,images]<2,>=1.8
+Requires-Dist: django-headless[schema]<2,>=1.1.1
+Requires-Dist: django<7,>=5.2
+Requires-Dist: djangorestframework<4,>=3.17
+Provides-Extra: s3
+Requires-Dist: django-storages[s3]>=1.14; extra == 's3'
+Provides-Extra: server
+Requires-Dist: gunicorn>=26; extra == 'server'
+Requires-Dist: psycopg[binary]>=3.2; extra == 'server'
+Requires-Dist: redis>=5; extra == 'server'
+Requires-Dist: uvicorn-worker>=0.3; extra == 'server'
+Requires-Dist: uvicorn[standard]>=0.34; extra == 'server'
+Requires-Dist: whitenoise>=6.9; extra == 'server'
+Description-Content-Type: text/markdown
+
+# django-stack
+
+The backend glue of [DjangoStack](https://github.com/dwarsbit/django-stack).
+Projects created with `npx @django-stack/cli init` depend on it.
+
+- `django_stack.settings.configure()` sets Django's settings from environment
+  variables: database, cache, task queue, mail, storage, security, and safe
+  defaults for Django Headless and Django Content Studio.
+- `PublishableModel`: draft and published content, with preview access.
+- API defaults: a closed API with a full-access and a read-only key, and
+  rate-limited public forms.
+- Preview tokens and signed revalidation requests to the frontend.
+- `/healthz` and `/readyz`, system checks, and the management commands
+  `create_admin`, `seed_content`, `export_content`, `import_content` and
+  `wait_for_db`.
+
+```python
+# config/settings.py
+from pathlib import Path
+
+from django_stack.settings import configure
+
+configure(globals(), base_dir=Path(__file__).resolve().parent.parent)
+```
+
+## License
+
+MIT; see [LICENSE](LICENSE).

django_stack-0.2.0/README.md

@@ -0,0 +1,28 @@
+# django-stack
+
+The backend glue of [DjangoStack](https://github.com/dwarsbit/django-stack).
+Projects created with `npx @django-stack/cli init` depend on it.
+
+- `django_stack.settings.configure()` sets Django's settings from environment
+  variables: database, cache, task queue, mail, storage, security, and safe
+  defaults for Django Headless and Django Content Studio.
+- `PublishableModel`: draft and published content, with preview access.
+- API defaults: a closed API with a full-access and a read-only key, and
+  rate-limited public forms.
+- Preview tokens and signed revalidation requests to the frontend.
+- `/healthz` and `/readyz`, system checks, and the management commands
+  `create_admin`, `seed_content`, `export_content`, `import_content` and
+  `wait_for_db`.
+
+```python
+# config/settings.py
+from pathlib import Path
+
+from django_stack.settings import configure
+
+configure(globals(), base_dir=Path(__file__).resolve().parent.parent)
+```
+
+## License
+
+MIT; see [LICENSE](LICENSE).

{django_stack-0.0.1 → django_stack-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "django-stack"
-version = "0.0.1"
+version = "0.2.0"
 description = "The backend glue of DjangoStack: settings from environment variables, API defaults, health checks and system checks."
 readme = "README.md"
 license = "MIT"
@@ -20,7 +20,23 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
 ]
-dependencies = ["Django>=5.2,<7"]
+dependencies = [
+    "Django>=5.2,<7",
+    "djangorestframework>=3.17,<4",
+    "django-headless[schema]>=1.1.1,<2",
+    "django-content-studio[images,huey]>=1.8,<2",
+]
+
+[project.optional-dependencies]
+server = [
+    "gunicorn>=26",
+    "uvicorn[standard]>=0.34",
+    "uvicorn-worker>=0.3",
+    "whitenoise>=6.9",
+    "psycopg[binary]>=3.2",
+    "redis>=5",
+]
+s3 = ["django-storages[s3]>=1.14"]
 
 [project.urls]
 Homepage = "https://github.com/dwarsbit/django-stack"
@@ -28,7 +44,13 @@ Source = "https://github.com/dwarsbit/django-stack/tree/main/python/django-stack
 Issues = "https://github.com/dwarsbit/django-stack/issues"
 
 [dependency-groups]
-dev = ["pytest>=8", "pytest-django>=4.11", "ruff>=0.15"]
+dev = [
+    "pytest>=8",
+    "pytest-django>=4.11",
+    "ruff>=0.15",
+    "django-storages[s3]>=1.14",
+    "whitenoise>=6.9",
+]
 
 [build-system]
 requires = ["hatchling>=1.27"]

{django_stack-0.0.1 → django_stack-0.2.0}/src/django_stack/__init__.py

@@ -1,3 +1,3 @@
 """The backend glue of DjangoStack."""
 
-__version__ = "0.0.1"
+__version__ = "0.2.0"

django_stack-0.2.0/src/django_stack/apps.py

@@ -0,0 +1,19 @@
+from django.apps import AppConfig
+
+
+class DjangoStackConfig(AppConfig):
+    name = "django_stack"
+    label = "django_stack"
+    verbose_name = "DjangoStack"
+
+    def ready(self):
+        from . import checks  # noqa: F401 - registers the system checks
+
+        try:
+            from content_studio.signals import content_changed
+        except ImportError:  # pragma: no cover - Content Studio is not installed
+            return
+
+        from .contrib.revalidate.receivers import on_content_changed
+
+        content_changed.connect(on_content_changed, dispatch_uid="django_stack_revalidate")

django_stack-0.2.0/src/django_stack/backup.py

@@ -0,0 +1,268 @@
+"""
+Backups: the database with ``pg_dump`` and, when uploads are stored on
+disk, the media directory as a ``.tar.gz``, to a directory and, optionally,
+to a private S3 bucket, with retention.
+
+The ``backup`` service of a project runs ``run_backups``, which calls
+:func:`create_backup` and :func:`create_media_backup` once a day.
+``backup_database`` makes them now, ``restore_database`` and
+``restore_media`` restore them.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import tarfile
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+from . import conf
+
+NAME_PATTERN = re.compile(r"^(?P<prefix>.+)-(?P<stamp>\d{8}T\d{6}Z)\.dump$")
+MEDIA_PATTERN = re.compile(r"^(?P<prefix>.+)-(?P<stamp>\d{8}T\d{6}Z)\.media\.tar\.gz$")
+MEDIA_SUFFIX = ".media.tar.gz"
+
+
+@dataclass
+class Backup:
+    name: str
+    path: Path
+    uploaded: bool = False
+
+
+def _database() -> dict:
+    database = settings.DATABASES["default"]
+    if "postgresql" not in database["ENGINE"]:
+        raise ImproperlyConfigured("Backups need a Postgres database; DATABASE_URL is not postgres://.")
+    return database
+
+
+def pg_environment(database: dict | None = None) -> dict[str, str]:
+    """The environment for pg_dump and pg_restore: connection values as PG* variables."""
+    database = database or _database()
+    env = dict(os.environ)
+    values = {
+        "PGHOST": database.get("HOST") or "localhost",
+        "PGPORT": str(database.get("PORT") or 5432),
+        "PGUSER": database.get("USER") or "",
+        "PGPASSWORD": database.get("PASSWORD") or "",
+        "PGDATABASE": database.get("NAME") or "",
+    }
+    sslmode = (database.get("OPTIONS") or {}).get("sslmode")
+    if sslmode:
+        values["PGSSLMODE"] = sslmode
+    env.update({key: value for key, value in values.items() if value})
+    return env
+
+
+def backup_dir() -> Path:
+    path = Path(conf.get("BACKUP_DIR") or Path(settings.BASE_DIR) / "backups")
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def backup_name(now: datetime | None = None) -> str:
+    now = now or datetime.now(UTC)
+    prefix = re.sub(r"[^a-zA-Z0-9_-]+", "-", getattr(settings, "PROJECT_NAME", "") or "backup")
+    return f"{prefix}-{now.strftime('%Y%m%dT%H%M%SZ')}.dump"
+
+
+def media_name(database_name: str) -> str:
+    """The media archive that belongs to a database dump: same name and time."""
+    return database_name.removesuffix(".dump") + MEDIA_SUFFIX
+
+
+def s3_client():
+    """A boto3 client for the backup bucket, with the S3_* credentials."""
+    import boto3
+
+    options = conf.get("BACKUP_S3") or {}
+    return boto3.client(
+        "s3",
+        endpoint_url=options.get("endpoint_url"),
+        region_name=options.get("region_name"),
+        aws_access_key_id=options.get("access_key"),
+        aws_secret_access_key=options.get("secret_key"),
+    )
+
+
+def _s3_target() -> tuple[str, str] | None:
+    bucket = conf.get("BACKUP_S3_BUCKET")
+    if not bucket:
+        return None
+    prefix = (conf.get("BACKUP_S3_PREFIX") or "").strip("/")
+    return bucket, f"{prefix}/" if prefix else ""
+
+
+def create_backup(*, keep: int | None = None, name: str | None = None) -> Backup:
+    """Dump the database, upload it when a backup bucket is set, and apply the retention."""
+    pg_dump = shutil.which("pg_dump")
+    if pg_dump is None:
+        raise ImproperlyConfigured("pg_dump is not installed; install the Postgres client.")
+    directory = backup_dir()
+    name = name or backup_name()
+    path = directory / name
+    partial = path.with_suffix(".partial")
+    subprocess.run(  # noqa: S603 (fixed arguments, no shell)
+        [pg_dump, "--format=custom", "--no-owner", "--no-acl", "--file", str(partial)],
+        env=pg_environment(),
+        check=True,
+        capture_output=True,
+    )
+    partial.rename(path)
+    path.chmod(0o600)
+    backup = Backup(name=name, path=path)
+
+    _upload(backup)
+    prune(keep if keep is not None else conf.get("BACKUP_KEEP"))
+    return backup
+
+
+def _upload(backup: Backup) -> None:
+    target = _s3_target()
+    if target:
+        bucket, prefix = target
+        s3_client().upload_file(str(backup.path), bucket, f"{prefix}{backup.name}")
+        backup.uploaded = True
+
+
+def media_on_disk() -> bool:
+    """Whether uploads are stored in MEDIA_ROOT, not in S3: only then the media needs a backup."""
+    backend = settings.STORAGES.get("default", {}).get("BACKEND", "")
+    return backend == "django.core.files.storage.FileSystemStorage"
+
+
+def media_backups_enabled() -> bool:
+    return bool(conf.get("BACKUP_MEDIA")) and media_on_disk()
+
+
+def create_media_backup(database_name: str, *, keep: int | None = None) -> Backup:
+    """Archive MEDIA_ROOT next to a database dump, upload it, and apply the retention."""
+    root = Path(settings.MEDIA_ROOT)
+    name = media_name(database_name)
+    path = backup_dir() / name
+    partial = path.with_name(f"{name}.partial")
+    with tarfile.open(partial, "w:gz") as archive:
+        if root.is_dir():
+            for entry in sorted(root.iterdir()):
+                if not entry.name.startswith(".restoring"):
+                    archive.add(entry, arcname=entry.name)
+    partial.rename(path)
+    path.chmod(0o600)
+    backup = Backup(name=name, path=path)
+    _upload(backup)
+    prune(keep if keep is not None else conf.get("BACKUP_KEEP"), pattern=MEDIA_PATTERN)
+    return backup
+
+
+def _sorted_names(names, pattern: re.Pattern = NAME_PATTERN) -> list[str]:
+    return sorted(
+        (name for name in names if pattern.match(name)),
+        key=lambda name: pattern.match(name)["stamp"],
+    )
+
+
+def local_backups(pattern: re.Pattern = NAME_PATTERN) -> list[str]:
+    return _sorted_names((path.name for path in backup_dir().iterdir()), pattern)
+
+
+def remote_backups(pattern: re.Pattern = NAME_PATTERN) -> list[str]:
+    target = _s3_target()
+    if not target:
+        return []
+    bucket, prefix = target
+    names = []
+    for page in s3_client().get_paginator("list_objects_v2").paginate(Bucket=bucket, Prefix=prefix):
+        names += [item["Key"][len(prefix) :] for item in page.get("Contents", [])]
+    return _sorted_names(names, pattern)
+
+
+def prune(keep: int, pattern: re.Pattern = NAME_PATTERN) -> list[str]:
+    """Delete all but the ``keep`` newest backups of a kind, locally and in the bucket."""
+    removed = []
+    if keep is None or keep <= 0:
+        return removed
+    for name in local_backups(pattern)[:-keep]:
+        (backup_dir() / name).unlink(missing_ok=True)
+        removed.append(name)
+    target = _s3_target()
+    if target:
+        bucket, prefix = target
+        client = s3_client()
+        for name in remote_backups(pattern)[:-keep]:
+            client.delete_object(Bucket=bucket, Key=f"{prefix}{name}")
+            removed.append(f"s3://{bucket}/{prefix}{name}")
+    return removed
+
+
+def fetch_backup(name: str) -> Path:
+    """The path of a local backup, downloading it from the bucket when it is only there."""
+    path = Path(name)
+    if path.is_file():
+        return path
+    local = backup_dir() / path.name
+    if local.is_file():
+        return local
+    target = _s3_target()
+    if target and (NAME_PATTERN.match(path.name) or MEDIA_PATTERN.match(path.name)):
+        bucket, prefix = target
+        s3_client().download_file(bucket, f"{prefix}{path.name}", str(local))
+        return local
+    raise FileNotFoundError(f"No backup named {name} in {backup_dir()} or the backup bucket.")
+
+
+def restore_backup(path: Path) -> None:
+    """Restore a dump over the current database: objects in the dump are dropped and recreated."""
+    pg_restore = shutil.which("pg_restore")
+    if pg_restore is None:
+        raise ImproperlyConfigured("pg_restore is not installed; install the Postgres client.")
+    subprocess.run(  # noqa: S603 (fixed arguments, no shell)
+        [
+            pg_restore,
+            "--clean",
+            "--if-exists",
+            "--no-owner",
+            "--no-acl",
+            "--single-transaction",
+            "--dbname",
+            _database()["NAME"],
+            str(path),
+        ],
+        env=pg_environment(),
+        check=True,
+        capture_output=True,
+    )
+
+
+def restore_media(path: Path) -> None:
+    """Replace the contents of MEDIA_ROOT with a media archive."""
+    root = Path(settings.MEDIA_ROOT)
+    root.mkdir(parents=True, exist_ok=True)
+    # Extract next to the current files first, so a broken archive changes nothing.
+    staging = root / ".restoring"
+    if staging.exists():
+        shutil.rmtree(staging)
+    staging.mkdir()
+    try:
+        with tarfile.open(path, "r:gz") as archive:
+            archive.extractall(staging, filter="data")
+    except Exception:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+    for entry in root.iterdir():
+        if entry == staging:
+            continue
+        if entry.is_dir() and not entry.is_symlink():
+            shutil.rmtree(entry)
+        else:
+            entry.unlink()
+    for entry in staging.iterdir():
+        entry.rename(root / entry.name)
+    staging.rmdir()

django_stack-0.2.0/src/django_stack/checks.py

@@ -0,0 +1,135 @@
+"""
+DjangoStack's system checks.
+
+- ``django_stack.E001``: the read-only API key is the full-access key.
+- ``django_stack.E002``: no read-only API key, so the frontend cannot read content.
+- ``django_stack.E003``: ``DEBUG`` is on while ``SITE_URL`` is https.
+- ``django_stack.E004``: a model in ``PUBLIC_CREATE`` is not installed.
+- ``django_stack.W001``: ``REVALIDATE_URL`` without ``REVALIDATE_SECRET``, so the
+  frontend is never told about changes.
+- ``django_stack.W002``: no ``PREVIEW_SECRET``, so editors cannot preview drafts.
+- ``django_stack.W003`` (deploy): ``SECRET_KEY`` shorter than 50 characters.
+- ``django_stack.W004`` (deploy): the cache is per process, so throttles,
+  sessions and presence are not shared between workers.
+- ``django_stack.W005`` (deploy): ``SITE_URL`` is https but ``NUM_PROXIES`` is 0,
+  so Django does not see that requests came in over HTTPS.
+"""
+
+from django.apps import apps
+from django.conf import settings
+from django.core.checks import Error, Tags, Warning, register
+
+from . import conf
+
+
+def _headless():
+    return getattr(settings, "HEADLESS", None) or {}
+
+
+@register(Tags.security)
+def check_api_keys(app_configs, **kwargs):
+    errors = []
+    write_key = _headless().get("AUTH_SECRET_KEY")
+    read_key = _headless().get("AUTH_READ_ONLY_SECRET_KEY")
+    if write_key and read_key and write_key == read_key:
+        errors.append(
+            Error(
+                "API_READ_KEY is the same as API_SECRET_KEY.",
+                hint="Generate a separate read-only key: the frontend must not hold a key that can write.",
+                id="django_stack.E001",
+            )
+        )
+    if not read_key:
+        errors.append(
+            Error(
+                "API_READ_KEY is not set.",
+                hint="Set API_READ_KEY: the frontend reads content with it.",
+                id="django_stack.E002",
+            )
+        )
+    return errors
+
+
+@register(Tags.security)
+def check_debug(app_configs, **kwargs):
+    site_url = getattr(settings, "SITE_URL", "") or ""
+    if settings.DEBUG and site_url.startswith("https://"):
+        return [
+            Error(
+                "DEBUG is on while SITE_URL is https.",
+                hint="Set DJANGO_DEBUG=0 in production: debug pages show settings and source code.",
+                id="django_stack.E003",
+            )
+        ]
+    return []
+
+
+@register()
+def check_public_create(app_configs, **kwargs):
+    errors = []
+    for label in conf.get("PUBLIC_CREATE"):
+        try:
+            apps.get_model(label)
+        except (LookupError, ValueError):
+            errors.append(
+                Error(
+                    f"PUBLIC_CREATE names {label!r}, which is not an installed model.",
+                    hint="Use the model's label, such as 'content.formsubmission'.",
+                    id="django_stack.E004",
+                )
+            )
+    return errors
+
+
+@register()
+def check_secrets(app_configs, **kwargs):
+    warnings = []
+    if conf.get("REVALIDATE_URL") and not conf.get("REVALIDATE_SECRET"):
+        warnings.append(
+            Warning(
+                "REVALIDATE_URL is set without REVALIDATE_SECRET.",
+                hint="Set REVALIDATE_SECRET to the same value as in the frontend.",
+                id="django_stack.W001",
+            )
+        )
+    if not conf.get("PREVIEW_SECRET"):
+        warnings.append(
+            Warning(
+                "PREVIEW_SECRET is not set, so editors cannot preview drafts.",
+                hint="Set PREVIEW_SECRET to the same value as in the frontend.",
+                id="django_stack.W002",
+            )
+        )
+    return warnings
+
+
+@register(Tags.security, deploy=True)
+def check_deploy(app_configs, **kwargs):
+    warnings = []
+    if len(settings.SECRET_KEY or "") < 50:
+        warnings.append(
+            Warning(
+                "DJANGO_SECRET_KEY is shorter than 50 characters.",
+                hint="Generate a new one, for example with `npx @django-stack/cli secret`.",
+                id="django_stack.W003",
+            )
+        )
+    backend = settings.CACHES.get("default", {}).get("BACKEND", "")
+    if backend.endswith(("LocMemCache", "DummyCache")):
+        warnings.append(
+            Warning(
+                "The default cache is not shared between processes.",
+                hint="Set CACHE_URL to the Valkey or Redis service.",
+                id="django_stack.W004",
+            )
+        )
+    site_url = getattr(settings, "SITE_URL", "") or ""
+    if site_url.startswith("https://") and not getattr(settings, "SECURE_PROXY_SSL_HEADER", None):
+        warnings.append(
+            Warning(
+                "SITE_URL is https, but Django does not trust the proxy's X-Forwarded-Proto header.",
+                hint="Set NUM_PROXIES=1 behind Caddy, so secure cookies and CSRF checks see HTTPS.",
+                id="django_stack.W005",
+            )
+        )
+    return warnings

django_stack-0.2.0/src/django_stack/conf.py

@@ -0,0 +1,33 @@
+"""Access to the DJANGO_STACK settings with their defaults."""
+
+from django.conf import settings
+
+DEFAULTS = {
+    "PREVIEW_SECRET": None,
+    "PREVIEW_MAX_AGE": 3600,
+    "PREVIEW_HEADER": "X-Preview-Token",
+    "REVALIDATE_URL": None,
+    "REVALIDATE_SECRET": None,
+    "REVALIDATE_TIMEOUT": 5,
+    "PUBLIC_CREATE": [],
+    "CONTENT_APPS": ["content"],
+    "SEED_CONTENT": None,
+    "ADMIN_USERNAME": "admin",
+    "ADMIN_EMAIL": None,
+    "ADMIN_PASSWORD": None,
+    "BACKUP_DIR": None,
+    "BACKUP_KEEP": 14,
+    "BACKUP_TIME": "03:00",
+    "BACKUP_S3_BUCKET": None,
+    "BACKUP_S3_PREFIX": "backups/",
+    "BACKUP_S3": {},
+    "BACKUP_MEDIA": True,
+    "BACKUP_DAILY": False,
+}
+
+
+def get(name: str):
+    configured = getattr(settings, "DJANGO_STACK", None) or {}
+    if name in configured:
+        return configured[name]
+    return DEFAULTS[name]

django_stack-0.2.0/src/django_stack/contrib/health/urls.py

@@ -0,0 +1,8 @@
+from django.urls import path
+
+from . import views
+
+urlpatterns = [
+    path("healthz", views.healthz, name="django-stack-healthz"),
+    path("readyz", views.readyz, name="django-stack-readyz"),
+]

django_stack-0.2.0/src/django_stack/contrib/health/views.py

@@ -0,0 +1,36 @@
+from django.core.cache import cache
+from django.db import connection
+from django.http import JsonResponse
+from django.views.decorators.cache import never_cache
+from django.views.decorators.http import require_GET
+
+
+@never_cache
+@require_GET
+def healthz(request):
+    """The process is up."""
+    return JsonResponse({"status": "ok"})
+
+
+@never_cache
+@require_GET
+def readyz(request):
+    """The database and the cache are reachable."""
+    checks = {}
+    try:
+        connection.ensure_connection()
+        with connection.cursor() as cursor:
+            cursor.execute("SELECT 1")
+        checks["database"] = "ok"
+    except Exception:  # noqa: BLE001
+        checks["database"] = "error"
+    try:
+        cache.set("django_stack:readyz", "1", 5)
+        checks["cache"] = "ok" if cache.get("django_stack:readyz") == "1" else "error"
+    except Exception:  # noqa: BLE001
+        checks["cache"] = "error"
+
+    ready = all(value == "ok" for value in checks.values())
+    return JsonResponse(
+        {"status": "ok" if ready else "error", "checks": checks}, status=200 if ready else 503
+    )

django_stack-0.2.0/src/django_stack/contrib/revalidate/receivers.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from ... import conf
+from .tasks import enqueue_revalidate
+
+
+def on_content_changed(sender, changes, **kwargs):
+    """Content Studio's content_changed signal: forward the changes to the frontend."""
+    if not conf.get("REVALIDATE_URL") or not conf.get("REVALIDATE_SECRET"):
+        return
+    payload = [
+        {
+            "action": change.action,
+            "model": change.model._meta.label_lower if change.model is not None else None,
+            "id": str(change.object_id) if change.object_id is not None else None,
+        }
+        for change in changes
+    ]
+    if payload:
+        enqueue_revalidate(payload)