codefortify-starter 1.0.0__py3-none-any.whl

codefortify_starter/templates/features/docker/Dockerfile.jinja

@@ -0,0 +1,20 @@
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip && pip install -r /app/requirements.txt
+
+COPY . /app
+
+RUN chmod +x /app/entrypoint.sh /app/docker_deploy.sh
+
+EXPOSE 8000
+
+ENTRYPOINT ["/app/entrypoint.sh"]
+CMD ["gunicorn", "core.wsgi:application", "--bind", "0.0.0.0:8000", "--workers", "3", "--timeout", "120"]
+

codefortify_starter/templates/features/docker/docker-compose.prod.yml.jinja

@@ -0,0 +1,158 @@
+name: [[ project_slug ]]
+
+services:
+  web:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: gunicorn core.wsgi:application --bind 0.0.0.0:8000 --workers ${GUNICORN_WORKERS:-3} --timeout ${GUNICORN_TIMEOUT:-120}
+    env_file:
+      - .env
+    environment:
+      CODEFORTIFY_ENVIRONMENT: production
+      DEBUG: "False"
+      ALLOWED_HOSTS: ${ALLOWED_HOSTS}
+      CSRF_TRUSTED_ORIGINS: ${CSRF_TRUSTED_ORIGINS}
+      WAIT_FOR_DB: "[% if use_postgres or use_mysql %]true[% else %]false[% endif %]"
+      DB_BACKEND: "[[ database ]]"
+      RUN_MIGRATIONS: ${RUN_MIGRATIONS:-true}
+      COLLECT_STATIC: ${COLLECT_STATIC:-true}
+[% if use_postgres %]
+      DATABASE_URL: postgres://${POSTGRES_USER:-[[ project_slug ]]}:${POSTGRES_PASSWORD:-change-me}@db:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-[[ project_slug ]]}
+      POSTGRES_HOST: db
+      POSTGRES_PORT: ${POSTGRES_PORT:-5432}
+[% elif use_mysql %]
+      DATABASE_URL: mysql://${MYSQL_USER:-[[ project_slug ]]}:${MYSQL_PASSWORD:-change-me}@db:${MYSQL_PORT:-3306}/${MYSQL_DATABASE:-[[ project_slug ]]}
+      MYSQL_HOST: db
+      MYSQL_PORT: ${MYSQL_PORT:-3306}
+[% else %]
+      DATABASE_URL: sqlite:////app/db.sqlite3
+[% endif %]
+[% if use_celery %]
+      REDIS_URL: redis://redis:6379/0
+      CELERY_BROKER_URL: redis://redis:6379/0
+      CELERY_RESULT_BACKEND: redis://redis:6379/1
+[% endif %]
+    volumes:
+      - static_data:/app/static_root
+      - media_data:/app/media
+[% if use_postgres or use_mysql or use_celery %]
+    depends_on:
+[% if use_postgres or use_mysql %]
+      db:
+        condition: service_healthy
+[% endif %]
+[% if use_celery %]
+      redis:
+        condition: service_healthy
+[% endif %]
+[% endif %]
+    ports:
+      - "${APP_PORT:-8000}:8000"
+    restart: unless-stopped
+
+[% if use_postgres %]
+  db:
+    image: postgres:16-alpine
+    env_file:
+      - .env
+    environment:
+      POSTGRES_DB: ${POSTGRES_DB:-[[ project_slug ]]}
+      POSTGRES_USER: ${POSTGRES_USER:-[[ project_slug ]]}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-change-me}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-[[ project_slug ]]} -d ${POSTGRES_DB:-[[ project_slug ]]}"]
+      interval: 10s
+      timeout: 5s
+      retries: 20
+      start_period: 10s
+    restart: unless-stopped
+[% elif use_mysql %]
+  db:
+    image: mysql:8.4
+    env_file:
+      - .env
+    environment:
+      MYSQL_DATABASE: ${MYSQL_DATABASE:-[[ project_slug ]]}
+      MYSQL_USER: ${MYSQL_USER:-[[ project_slug ]]}
+      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-change-me}
+      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-root-change-me}
+    volumes:
+      - mysql_data:/var/lib/mysql
+    healthcheck:
+      test: ["CMD-SHELL", "mysqladmin ping -h localhost -u${MYSQL_USER:-[[ project_slug ]]} -p${MYSQL_PASSWORD:-change-me}"]
+      interval: 10s
+      timeout: 5s
+      retries: 30
+      start_period: 20s
+    restart: unless-stopped
+[% endif %]
+[% if use_celery %]
+  redis:
+    image: redis:7-alpine
+    command: redis-server --appendonly yes
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 20
+      start_period: 5s
+    restart: unless-stopped
+
+  celery:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: celery -A core worker -l info
+    env_file:
+      - .env
+    environment:
+      CODEFORTIFY_ENVIRONMENT: production
+      DEBUG: "False"
+      DB_BACKEND: "[[ database ]]"
+      WAIT_FOR_DB: "[% if use_postgres or use_mysql %]true[% else %]false[% endif %]"
+      RUN_MIGRATIONS: "false"
+      COLLECT_STATIC: "false"
+[% if use_postgres %]
+      DATABASE_URL: postgres://${POSTGRES_USER:-[[ project_slug ]]}:${POSTGRES_PASSWORD:-change-me}@db:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-[[ project_slug ]]}
+      POSTGRES_HOST: db
+      POSTGRES_PORT: ${POSTGRES_PORT:-5432}
+[% elif use_mysql %]
+      DATABASE_URL: mysql://${MYSQL_USER:-[[ project_slug ]]}:${MYSQL_PASSWORD:-change-me}@db:${MYSQL_PORT:-3306}/${MYSQL_DATABASE:-[[ project_slug ]]}
+      MYSQL_HOST: db
+      MYSQL_PORT: ${MYSQL_PORT:-3306}
+[% else %]
+      DATABASE_URL: sqlite:////app/db.sqlite3
+[% endif %]
+      REDIS_URL: redis://redis:6379/0
+      CELERY_BROKER_URL: redis://redis:6379/0
+      CELERY_RESULT_BACKEND: redis://redis:6379/1
+[% if use_postgres or use_mysql %]
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+[% else %]
+    depends_on:
+      redis:
+        condition: service_healthy
+[% endif %]
+    restart: unless-stopped
+[% endif %]
+
+volumes:
+[% if use_postgres %]
+  postgres_data:
+[% elif use_mysql %]
+  mysql_data:
+[% endif %]
+[% if use_celery %]
+  redis_data:
+[% endif %]
+  static_data:
+  media_data:

codefortify_starter/templates/features/docker/docker-compose.yml.jinja

@@ -0,0 +1,208 @@
+name: [[ project_slug ]]
+
+services:
+  web:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: python manage.py runserver 0.0.0.0:8000
+    env_file:
+      - .env
+    environment:
+      CODEFORTIFY_ENVIRONMENT: ${CODEFORTIFY_ENVIRONMENT:-dev}
+      DEBUG: ${DEBUG:-True}
+      ALLOWED_HOSTS: ${ALLOWED_HOSTS:-localhost,127.0.0.1,0.0.0.0}
+      CSRF_TRUSTED_ORIGINS: ${CSRF_TRUSTED_ORIGINS:-http://localhost:8000,http://127.0.0.1:8000}
+      WAIT_FOR_DB: "[% if use_postgres or use_mysql %]true[% else %]false[% endif %]"
+      DB_BACKEND: "[[ database ]]"
+      RUN_MIGRATIONS: "true"
+      COLLECT_STATIC: "false"
+[% if use_postgres %]
+      DATABASE_URL: postgres://${POSTGRES_USER:-[[ project_slug ]]}:${POSTGRES_PASSWORD:-change-me}@db:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-[[ project_slug ]]}
+      POSTGRES_HOST: db
+      POSTGRES_PORT: ${POSTGRES_PORT:-5432}
+[% elif use_mysql %]
+      DATABASE_URL: mysql://${MYSQL_USER:-[[ project_slug ]]}:${MYSQL_PASSWORD:-change-me}@db:${MYSQL_PORT:-3306}/${MYSQL_DATABASE:-[[ project_slug ]]}
+      MYSQL_HOST: db
+      MYSQL_PORT: ${MYSQL_PORT:-3306}
+[% else %]
+      DATABASE_URL: sqlite:////app/db.sqlite3
+[% endif %]
+[% if use_celery %]
+      REDIS_URL: redis://redis:6379/0
+      CELERY_BROKER_URL: redis://redis:6379/0
+      CELERY_RESULT_BACKEND: redis://redis:6379/1
+[% endif %]
+    volumes:
+      - .:/app
+      - static_data:/app/static_root
+      - media_data:/app/media
+[% if use_postgres or use_mysql or use_celery %]
+    depends_on:
+[% if use_postgres or use_mysql %]
+      db:
+        condition: service_healthy
+[% endif %]
+[% if use_celery %]
+      redis:
+        condition: service_healthy
+[% endif %]
+[% endif %]
+    ports:
+      - "${APP_PORT:-8000}:8000"
+    restart: unless-stopped
+
+[% if use_postgres %]
+  db:
+    image: postgres:16-alpine
+    env_file:
+      - .env
+    environment:
+      POSTGRES_DB: ${POSTGRES_DB:-[[ project_slug ]]}
+      POSTGRES_USER: ${POSTGRES_USER:-[[ project_slug ]]}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-change-me}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-[[ project_slug ]]} -d ${POSTGRES_DB:-[[ project_slug ]]}"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+      start_period: 5s
+    restart: unless-stopped
+[% elif use_mysql %]
+  db:
+    image: mysql:8.4
+    env_file:
+      - .env
+    environment:
+      MYSQL_DATABASE: ${MYSQL_DATABASE:-[[ project_slug ]]}
+      MYSQL_USER: ${MYSQL_USER:-[[ project_slug ]]}
+      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-change-me}
+      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-root-change-me}
+    volumes:
+      - mysql_data:/var/lib/mysql
+    healthcheck:
+      test: ["CMD-SHELL", "mysqladmin ping -h localhost -u${MYSQL_USER:-[[ project_slug ]]} -p${MYSQL_PASSWORD:-change-me}"]
+      interval: 10s
+      timeout: 5s
+      retries: 30
+      start_period: 20s
+    restart: unless-stopped
+[% endif %]
+[% if use_celery %]
+  redis:
+    image: redis:7-alpine
+    command: redis-server --appendonly yes
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+      start_period: 5s
+    restart: unless-stopped
+
+  celery:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: celery -A core worker -l info
+    env_file:
+      - .env
+    environment:
+      CODEFORTIFY_ENVIRONMENT: ${CODEFORTIFY_ENVIRONMENT:-dev}
+      DEBUG: ${DEBUG:-True}
+      DB_BACKEND: "[[ database ]]"
+      WAIT_FOR_DB: "[% if use_postgres or use_mysql %]true[% else %]false[% endif %]"
+      RUN_MIGRATIONS: "false"
+      COLLECT_STATIC: "false"
+[% if use_postgres %]
+      DATABASE_URL: postgres://${POSTGRES_USER:-[[ project_slug ]]}:${POSTGRES_PASSWORD:-change-me}@db:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-[[ project_slug ]]}
+      POSTGRES_HOST: db
+      POSTGRES_PORT: ${POSTGRES_PORT:-5432}
+[% elif use_mysql %]
+      DATABASE_URL: mysql://${MYSQL_USER:-[[ project_slug ]]}:${MYSQL_PASSWORD:-change-me}@db:${MYSQL_PORT:-3306}/${MYSQL_DATABASE:-[[ project_slug ]]}
+      MYSQL_HOST: db
+      MYSQL_PORT: ${MYSQL_PORT:-3306}
+[% else %]
+      DATABASE_URL: sqlite:////app/db.sqlite3
+[% endif %]
+      REDIS_URL: redis://redis:6379/0
+      CELERY_BROKER_URL: redis://redis:6379/0
+      CELERY_RESULT_BACKEND: redis://redis:6379/1
+    volumes:
+      - .:/app
+[% if use_postgres or use_mysql %]
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+[% else %]
+    depends_on:
+      redis:
+        condition: service_healthy
+[% endif %]
+    restart: unless-stopped
+
+  celery-beat:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: celery -A core beat -l info --scheduler celery.beat:PersistentScheduler --pidfile=
+    profiles:
+      - beat
+    env_file:
+      - .env
+    environment:
+      CODEFORTIFY_ENVIRONMENT: ${CODEFORTIFY_ENVIRONMENT:-dev}
+      DEBUG: ${DEBUG:-True}
+      DB_BACKEND: "[[ database ]]"
+      WAIT_FOR_DB: "[% if use_postgres or use_mysql %]true[% else %]false[% endif %]"
+      RUN_MIGRATIONS: "false"
+      COLLECT_STATIC: "false"
+[% if use_postgres %]
+      DATABASE_URL: postgres://${POSTGRES_USER:-[[ project_slug ]]}:${POSTGRES_PASSWORD:-change-me}@db:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-[[ project_slug ]]}
+      POSTGRES_HOST: db
+      POSTGRES_PORT: ${POSTGRES_PORT:-5432}
+[% elif use_mysql %]
+      DATABASE_URL: mysql://${MYSQL_USER:-[[ project_slug ]]}:${MYSQL_PASSWORD:-change-me}@db:${MYSQL_PORT:-3306}/${MYSQL_DATABASE:-[[ project_slug ]]}
+      MYSQL_HOST: db
+      MYSQL_PORT: ${MYSQL_PORT:-3306}
+[% else %]
+      DATABASE_URL: sqlite:////app/db.sqlite3
+[% endif %]
+      REDIS_URL: redis://redis:6379/0
+      CELERY_BROKER_URL: redis://redis:6379/0
+      CELERY_RESULT_BACKEND: redis://redis:6379/1
+    volumes:
+      - .:/app
+      - celery_beat_data:/app/.celerybeat
+[% if use_postgres or use_mysql %]
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+[% else %]
+    depends_on:
+      redis:
+        condition: service_healthy
+[% endif %]
+    restart: unless-stopped
+[% endif %]
+
+volumes:
+[% if use_postgres %]
+  postgres_data:
+[% elif use_mysql %]
+  mysql_data:
+[% endif %]
+[% if use_celery %]
+  redis_data:
+  celery_beat_data:
+[% endif %]
+  static_data:
+  media_data:

codefortify_starter/templates/features/docker/docker_deploy.sh.jinja

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${SCRIPT_DIR}"
+ENV_FILE="${PROJECT_ROOT}/.env"
+ENV_EXAMPLE="${PROJECT_ROOT}/.env.example"
+
+COMPOSE_FILE="docker-compose.yml"
+if [ "${1:-}" = "--prod" ]; then
+  COMPOSE_FILE="docker-compose.prod.yml"
+  shift
+fi
+
+ACTION="${1:-up}"
+LOG_SERVICE="${2:-web}"
+
+log() {
+  printf '[docker_deploy] %s\n' "$*"
+}
+
+die() {
+  printf '[docker_deploy][error] %s\n' "$*" >&2
+  exit 1
+}
+
+usage() {
+  cat <<EOF
+Usage:
+  ./docker_deploy.sh [--prod] [action] [service]
+
+Actions:
+  up            Build and start services, then run migrate/check
+  down          Stop and remove services
+  restart       Rebuild and restart services
+  ps            Show container status
+  logs [svc]    Tail logs (default service: web)
+  migrate       Run Django migrations in web
+  check         Run Django checks in web
+  test          Run Django tests in web
+  shell         Open shell in web container
+EOF
+}
+
+ensure_docker() {
+  command -v docker >/dev/null 2>&1 || die "Docker is not installed."
+  docker info >/dev/null 2>&1 || die "Docker daemon is not reachable."
+  docker compose version >/dev/null 2>&1 || die "Docker Compose v2 is required."
+}
+
+ensure_env_file() {
+  if [ ! -f "${ENV_FILE}" ]; then
+    [ -f "${ENV_EXAMPLE}" ] || die ".env is missing and .env.example was not found."
+    cp "${ENV_EXAMPLE}" "${ENV_FILE}"
+    log "Created .env from .env.example"
+  fi
+}
+
+compose() {
+  docker compose --env-file "${ENV_FILE}" -f "${PROJECT_ROOT}/${COMPOSE_FILE}" "$@"
+}
+
+start_services() {
+  log "Building images with ${COMPOSE_FILE}"
+  compose build
+
+[% if use_postgres or use_mysql %]
+  log "Starting database"
+  compose up -d db
+[% endif %]
+[% if use_celery %]
+  log "Starting redis"
+  compose up -d redis
+[% endif %]
+
+  log "Starting web"
+  compose up -d web
+[% if use_celery %]
+  log "Starting celery worker"
+  compose up -d celery
+[% endif %]
+
+  log "Running migrations"
+  compose exec -T web python manage.py migrate --noinput
+
+  log "Running Django checks"
+  compose exec -T web python manage.py check
+
+  log "Service status"
+  compose ps
+}
+
+ensure_docker
+ensure_env_file
+
+case "${ACTION}" in
+  up)
+    start_services
+    ;;
+  down)
+    compose down
+    ;;
+  restart)
+    compose down
+    start_services
+    ;;
+  ps)
+    compose ps
+    ;;
+  logs)
+    compose logs -f "${LOG_SERVICE}"
+    ;;
+  migrate)
+    compose exec -T web python manage.py migrate --noinput
+    ;;
+  check)
+    compose exec -T web python manage.py check
+    ;;
+  test)
+    compose exec -T web python manage.py test
+    ;;
+  shell)
+    compose exec web bash
+    ;;
+  -h|--help|help)
+    usage
+    ;;
+  *)
+    usage
+    die "Unknown action: ${ACTION}"
+    ;;
+esac

codefortify_starter/templates/features/docker/dot-dockerignore

@@ -0,0 +1,12 @@
+.git
+.venv
+venv
+__pycache__
+*.pyc
+.pytest_cache
+.mypy_cache
+media
+static_root
+dist
+build
+

codefortify_starter/templates/features/docker/entrypoint.sh.jinja

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+log() {
+  printf '[entrypoint] %s\n' "$*"
+}
+
+is_true() {
+  case "${1:-}" in
+    1|true|TRUE|True|yes|YES|on|ON) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+wait_for_database() {
+  python - <<'PY'
+import os
+import time
+import sys
+
+backend = (os.environ.get("DB_BACKEND") or "").strip().lower()
+timeout = int(os.environ.get("DB_WAIT_TIMEOUT", "120"))
+
+if backend in {"", "sqlite"}:
+    raise SystemExit(0)
+
+started = time.time()
+last_error = "unknown error"
+
+while True:
+    try:
+        if backend == "postgres":
+            import psycopg2
+
+            dsn = (os.environ.get("DATABASE_URL") or "").strip()
+            if dsn:
+                conn = psycopg2.connect(dsn)
+            else:
+                conn = psycopg2.connect(
+                    host=os.environ.get("POSTGRES_HOST", "db"),
+                    port=int(os.environ.get("POSTGRES_PORT", "5432")),
+                    user=os.environ.get("POSTGRES_USER", "postgres"),
+                    password=os.environ.get("POSTGRES_PASSWORD", ""),
+                    dbname=os.environ.get("POSTGRES_DB", "postgres"),
+                )
+            conn.close()
+            raise SystemExit(0)
+
+        if backend == "mysql":
+            import pymysql
+
+            conn = pymysql.connect(
+                host=os.environ.get("MYSQL_HOST", "db"),
+                port=int(os.environ.get("MYSQL_PORT", "3306")),
+                user=os.environ.get("MYSQL_USER", "root"),
+                password=os.environ.get("MYSQL_PASSWORD", ""),
+                database=os.environ.get("MYSQL_DATABASE", ""),
+                connect_timeout=5,
+            )
+            conn.close()
+            raise SystemExit(0)
+
+        raise SystemExit(0)
+    except SystemExit:
+        raise
+    except Exception as exc:
+        last_error = str(exc)
+        if time.time() - started > timeout:
+            print(f"database did not become ready within {timeout}s: {last_error}", file=sys.stderr)
+            raise SystemExit(1)
+        time.sleep(1)
+PY
+}
+
+mkdir -p /app/static_root /app/media
+
+if is_true "${WAIT_FOR_DB:-true}"; then
+  log "Waiting for database backend ${DB_BACKEND:-sqlite}"
+  wait_for_database
+  log "Database is ready"
+fi
+
+if is_true "${RUN_MIGRATIONS:-true}"; then
+  log "Running migrations"
+  python manage.py migrate --noinput
+fi
+
+if is_true "${COLLECT_STATIC:-false}"; then
+  log "Collecting static files"
+  python manage.py collectstatic --noinput
+fi
+
+log "Starting: $*"
+exec "$@"
+

codefortify_starter/templates/features/drf/apps/api/__init__.py

@@ -0,0 +1 @@
+

codefortify_starter/templates/features/drf/apps/api/apps.py.jinja

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class ApiConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "apps.api"
+

codefortify_starter/templates/features/drf/apps/api/serializers.py

@@ -0,0 +1,7 @@
+from rest_framework import serializers
+
+
+class HealthSerializer(serializers.Serializer):
+    status = serializers.CharField()
+    service = serializers.CharField()
+

codefortify_starter/templates/features/drf/apps/api/tests.py

@@ -0,0 +1,11 @@
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.test import APITestCase
+
+
+class HealthApiTests(APITestCase):
+    def test_health_endpoint(self):
+        response = self.client.get(reverse("api:health"))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data["status"], "ok")
+

codefortify_starter/templates/features/drf/apps/api/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+
+from apps.api.views import HealthAPIView
+
+
+app_name = "api"
+
+urlpatterns = [
+    path("health/", HealthAPIView.as_view(), name="health"),
+]
+

codefortify_starter/templates/features/drf/apps/api/views.py

@@ -0,0 +1,16 @@
+from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from apps.api.serializers import HealthSerializer
+
+
+class HealthAPIView(APIView):
+    authentication_classes = []
+    permission_classes = [AllowAny]
+
+    def get(self, request):
+        serializer = HealthSerializer(data={"status": "ok", "service": "api"})
+        serializer.is_valid(raise_exception=True)
+        return Response(serializer.validated_data)
+

codefortify_starter/templates/features/htmx/templates/partials/example.html.jinja

@@ -0,0 +1,5 @@
+<div>
+    <p>HTMX is active in this starter.</p>
+    <small>Server-rendered fragment updated at {% now "Y-m-d H:i:s" %}</small>
+</div>
+