Обробка помилок, Middleware та CORS у FastAPI

from fastapi import FastAPI, HTTPException, status

app = FastAPI()

@app.post("/accounts/{account_id}/withdraw")
async def withdraw(account_id: int, amount: float):
    user_balance = 150.00
    if amount > user_balance:
        # Передаємо структурований словник у detail
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail={
                "type": "https://kostyl.dev/errors/insufficient-funds",
                "title": "Недостатньо коштів на балансі",
                "status": 400,
                "detail": f"На вашому рахунку {user_balance:.2f} UAH. Спроба списання: {amount:.2f} UAH",
                "instance": f"/accounts/{account_id}/withdraw"
            }
        )
    return {"status": "success", "withdrawn": amount}

# custom_exceptions_demo.py
from fastapi import FastAPI, Request, status
from fastapi.responses import JSONResponse

app = FastAPI()

# --- ДОМЕННІ ВИКЛЮЧЕННЯ ---

class DomainException(Exception):
    """Базове виключення домену."""
    pass

class ProjectNotFoundError(DomainException):
    """Помилка: Проєкт не знайдено."""
    pass

class AccessDeniedError(DomainException):
    """Помилка: Відсутні права доступу."""
    pass

# --- ГЛОБАЛЬНІ ОБРОБНИКИ (EXCEPTION HANDLERS) ---

@app.exception_handler(ProjectNotFoundError)
async def project_not_found_handler(request: Request, exc: ProjectNotFoundError):
    # Повертаємо 404 статус
    return JSONResponse(
        status_code=status.HTTP_404_NOT_FOUND,
        content={
            "error_code": "PROJECT_NOT_FOUND",
            "message": str(exc),
            "path": request.url.path
        }
    )

@app.exception_handler(AccessDeniedError)
async def access_denied_handler(request: Request, exc: AccessDeniedError):
    # Повертаємо 403 статус
    return JSONResponse(
        status_code=status.HTTP_403_FORBIDDEN,
        content={
            "error_code": "FORBIDDEN",
            "message": str(exc),
            "path": request.url.path
        }
    )

@app.exception_handler(DomainException)
async def generic_domain_handler(request: Request, exc: DomainException):
    # Обробник для всіх інших доменних помилок (наприклад, 400 Bad Request)
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content={
            "error_code": "BAD_REQUEST",
            "message": str(exc)
        }
    )

# --- БІЗНЕС-ЛОГІКА ТА МАРШРУТИ ---

# Симульовані дані
PROJECTS = {1: {"title": "TaskForge Backend", "owner_id": 10}}

@app.get("/projects/{project_id}")
async def get_project(project_id: int, current_user_id: int = 99):
    # 1. Ендпоінт не думає про статус-коди HTTP — він оперує виключеннями домену
    if project_id not in PROJECTS:
        raise ProjectNotFoundError(f"Проєкт із ID {project_id} не існує")

    project = PROJECTS[project_id]
    if project["owner_id"] != current_user_id:
        raise AccessDeniedError("У вас немає прав для перегляду цього проєкту")

    return project

# validation_errors_demo.py
from fastapi import FastAPI, Request, status
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field

app = FastAPI()

# Глобально перевизначаємо обробник для RequestValidationError
@app.exception_handler(RequestValidationError)
async def custom_validation_exception_handler(request: Request, exc: RequestValidationError):
    errors_dict = {}

    # Проходимо по всьому списку помилок валідації
    for error in exc.errors():
        # loc містить шлях до поля, наприклад ["body", "title"] або ["body", "items", 2, "price"]
        # Візьмемо останній елемент шляху як назву поля
        field_name = error["loc"][-1] if error["loc"] else "custom_error"
        errors_dict[str(field_name)] = error["msg"]

    return JSONResponse(
        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
        content={"errors": errors_dict}
    )

# --- МОДЕЛЬ ДЛЯ ПЕРЕВІРКИ ---

class ProjectSchema(BaseModel):
    title: str = Field(..., min_length=3)
    budget: float = Field(..., gt=0.0)

@app.post("/projects")
async def create_project(project: ProjectSchema):
    return {"status": "created", "project": project}

import time
from fastapi import FastAPI, Request

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    # 1. SETUP ФАЗА (до виконання роуту)
    start_time = time.perf_counter()

    # 2. Передача контролю далі в конвеєр
    response = await call_next(request)

    # 3. CLEANUP ФАЗА (після виконання роуту)
    process_time = time.perf_counter() - start_time
    response.headers["X-Process-Time"] = f"{process_time:.6f}"

    return response

from fastapi import FastAPI, Request
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.responses import Response

class CustomHeaderMiddleware(BaseHTTPMiddleware):
    def __init__(self, app, header_name: str, header_value: str):
        # Обов'язково викликаємо конструктор базового класу
        super().__init__(app)
        self.header_name = header_name
        self.header_value = header_value

    async def dispatch(self, request: Request, call_next) -> Response:
        # Викликаємо наступний посередник
        response = await call_next(request)
        # Додаємо сконфігурований заголовок
        response.headers[self.header_name] = self.header_value
        return response

app = FastAPI()

# Реєструємо клас-посередник та передаємо додаткові аргументи
app.add_middleware(
    CustomHeaderMiddleware,
    header_name="X-Custom-System",
    header_value="TaskForgeEngine-1.0"
)

# pure_asgi_middleware.py
from fastapi import FastAPI

class PureASGIHeaderMiddleware:
    def __init__(self, app):
        self.app = app

    async def __call__(self, scope, receive, send):
        # Ми обробляємо лише HTTP-запити (ігноруємо WebSocket або Lifespan)
        if scope["type"] != "http":
            await self.app(scope, receive, send)
            return

        # Декоруємо функцію відправки відповідей send
        async def custom_send(message):
            # Якщо повідомлення є стартом HTTP-відповіді, додаємо заголовок
            if message["type"] == "http.response.start":
                # Перетворюємо headers на список кортежів байт (вимога ASGI специфікації)
                headers = list(message.get("headers", []))
                headers.append((b"x-pure-asgi", b"true"))
                message["headers"] = headers

            # Передаємо повідомлення далі ASGI-серверу
            await send(message)

        # Викликаємо додаток, передаючи оригінальний scope, receive та модифікований send
        await self.app(scope, receive, custom_send)

app = FastAPI()

# Підключаємо чистий ASGI посередник
app.add_middleware(PureASGIHeaderMiddleware)

@app.get("/")
async def index():
    return {"message": "Hello from Pure ASGI Middleware!"}

# custom_middlewares_demo.py
import time
import uuid
from contextvars import ContextVar
from fastapi import FastAPI, Request

# 1. Створюємо контекстну змінну для збереження Request ID (аналог AsyncLocal в C#)
request_id_var: ContextVar[str] = ContextVar("request_id", default="")

# Функція-помічник для отримання Request ID у будь-якому місці коду (наприклад, у логері)
def get_current_request_id() -> str:
    return request_id_var.get()

app = FastAPI()

# 2. Посередник для трасування та логування запитів
@app.middleware("http")
async def audit_and_tracing_middleware(request: Request, call_next):
    # А. Зчитуємо Request ID від клієнта або генеруємо новий UUID
    client_request_id = request.headers.get("X-Request-ID")
    request_id = client_request_id if client_request_id else str(uuid.uuid4())
    
    # Б. Встановлюємо значення в ContextVar (ізольоване для поточного асинхронного таска)
    token = request_id_var.set(request_id)
    
    start_time = time.perf_counter()
    
    # Виводимо структурований лог початку запиту
    print(f"[LOG] [{request_id}] START: {request.method} {request.url.path}")
    
    try:
        # В. Передаємо запит далі в конвеєр
        response = await call_next(request)
        
        # Г. Додаємо заголовок з Request ID у відповідь клієнту
        response.headers["X-Request-ID"] = request_id
        
        # Обчислюємо час обробки запиту
        process_time = time.perf_counter() - start_time
        response.headers["X-Process-Time"] = f"{process_time:.6f}"
        
        # Виводимо структурований лог завершення запиту
        print(f"[LOG] [{request_id}] END: {request.method} {request.url.path} | Status: {response.status_code} | Time: {process_time:.6f}s")
        
        return response
        
    finally:
        # Д. Обов'язково скидаємо значення контексту до початкового стану після завершення
        request_id_var.reset(token)

# --- ЕНДПОІНТИ ---

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    # Звертаємося до нашої контекстної змінної
    current_rid = get_current_request_id()
    
    # Будь-який внутрішній сервіс тепер може отримати цей ID без прокидання через параметри!
    print(f"[LOG] [{current_rid}] Бізнес-логіка: обробляємо товар з ID {item_id}")
    
    return {"item_id": item_id, "name": f"Product {item_id}", "request_id": current_rid}

# custom_rate_limiter.py
from fastapi import Request
from slowapi.util import get_remote_address

def get_user_or_ip_limit_key(request: Request) -> str:
    """
    Повертає ключ лімітування: ID користувача, якщо він авторизований,
    або IP-адресу для анонімних запитів.
    """
    # Припускаємо, що попередній middleware записав об'єкт користувача у request.state.user
    user = getattr(request.state, "user", None)
    if user and hasattr(user, "id"):
        return f"user_id:{user.id}"

    # Резервний варіант — IP-адреса клієнта
    return get_remote_address(request)

# security_and_rate_limit_demo.py
from fastapi import FastAPI, Request, status
from fastapi.responses import JSONResponse
from fastapi.middleware.trustedhost import TrustedHostMiddleware
from slowapi import Limiter
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded

# 1. Ініціалізуємо лімітер (ідентифікація за IP-адресою відправника)
limiter = Limiter(key_func=get_remote_address)
app = FastAPI(title="Security & Rate Limiting Demo")
app.state.limiter = limiter

# 2. Додаємо кастомний обробник перевищення ліміту для повернення гарного JSON
@app.exception_handler(RateLimitExceeded)
async def custom_rate_limit_handler(request: Request, exc: RateLimitExceeded):
    return JSONResponse(
        status_code=status.HTTP_429_TOO_MANY_REQUESTS,
        content={
            "error": "TOO_MANY_REQUESTS",
            "message": "Ви перевищили ліміт запитів. Спробуйте пізніше.",
            "limit": exc.detail
        }
    )

# 3. Додаємо TrustedHostMiddleware (дозволяємо лише localhost та 127.0.0.1)
app.add_middleware(
    TrustedHostMiddleware,
    allowed_hosts=["localhost", "127.0.0.1"]
)

# 4. Захищаємо ендпоінт правилом: максимум 5 запитів на хвилину
@app.get("/ping")
@limiter.limit("5/minute")
async def ping(request: Request):
    return {"message": "pong"}

# global_envelope_exception.py
import logging
import traceback
from fastapi import FastAPI, Request, status
from fastapi.responses import JSONResponse

# Налаштовуємо стандартне логування
logging.basicConfig(level=logging.ERROR, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger("GlobalLogger")

app = FastAPI(title="Global Error Envelope Demo")

# Глобальний обробник усіх непередбачених помилок
@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    # Логуємо помилку разом зі стек-трейсом
    logger.error(f"Необроблена помилка під час обробки {request.method} {request.url.path}: {str(exc)}")
    logger.error(traceback.format_exc())

    # Повертаємо уніфіковану відповідь
    return JSONResponse(
        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
        content={
            "error": "INTERNAL_SERVER_ERROR",
            "message": "Внутрішня помилка сервера. Будь ласка, зверніться до служби підтримки.",
            "details": None
        }
    )

@app.get("/trigger-error")
async def trigger_error():
    # Симулюємо непередбачену помилку (наприклад, ZeroDivisionError)
    result = 1 / 0
    return {"result": result}

# trace_logging_middleware.py
import time
import uuid
import logging
from contextvars import ContextVar
from fastapi import FastAPI, Request
from starlette.middleware.base import BaseHTTPMiddleware

# Асинхронно-безпечний контекст для збереження Correlation ID
correlation_id_var: ContextVar[str] = ContextVar("correlation_id", default="")

# Налаштовуємо логування, додаючи correlation_id до кожного запису
logging.basicConfig(level=logging.INFO, format="[%(asctime)s] [%(levelname)s] [ID: %(correlation_id)s] %(message)s")
logger = logging.getLogger("TraceLogger")

# Спеціальний фільтр для логера, який підтягує значення з contextvars
class CorrelationIdFilter(logging.Filter):
    def filter(self, record):
        record.correlation_id = correlation_id_var.get()
        return True

logger.addFilter(CorrelationIdFilter())

app = FastAPI(title="Correlation ID Tracing Demo")

class CorrelationIdMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        # 1. Генеруємо або зчитуємо існуючий Correlation ID із заголовків
        corr_id = request.headers.get("X-Correlation-ID", str(uuid.uuid4()))

        # 2. Встановлюємо значення у contextvars
        token = correlation_id_var.set(corr_id)

        start_time = time.perf_counter()
        logger.info(f"Початок запиту: {request.method} {request.url.path}")

        try:
            # 3. Передаємо запит далі по конвеєру
            response = await call_next(request)
        finally:
            # 4. Вимірюємо тривалість обробки
            process_time = time.perf_counter() - start_time
            logger.info(f"Завершення запиту: {request.method} {request.url.path} зі статусом {response.status_code}. Час: {process_time:.4f}s")

            # 5. Додаємо Correlation ID до заголовків відповіді
            response.headers["X-Correlation-ID"] = corr_id

            # 6. Скидаємо значення contextvars до попереднього
            correlation_id_var.reset(token)

        return response

# Додаємо посередник до конвеєра
app.add_middleware(CorrelationIdMiddleware)

@app.get("/data")
async def get_data():
    logger.info("Виконання бізнес-логіки ендпоінту...")
    return {"status": "success", "data": "Деякі конфіденційні дані"}

# custom_sliding_window.py
import time
import asyncio
from collections import defaultdict
from fastapi import FastAPI, Request, status
from fastapi.responses import JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware

app = FastAPI(title="Custom Sliding Window Rate Limiter")

class SlidingWindowRateLimiter(BaseHTTPMiddleware):
    def __init__(self, app, limit: int, window_seconds: int):
        super().__init__(app)
        self.limit = limit
        self.window_seconds = window_seconds
        # Зберігає мітки часу запитів для кожної IP-адреси: {ip: [timestamp1, timestamp2, ...]}
        self.requests_history = defaultdict(list)
        # Блокування для безпечного конкурентного оновлення словника
        self.lock = asyncio.Lock()

    async def dispatch(self, request: Request, call_next):
        client_ip = request.client.host if request.client else "unknown-ip"
        current_time = time.time()

        async with self.lock:
            # Очищуємо застарілі мітки часу, які вийшли за межі часового вікна
            valid_timestamps = [
                t for t in self.requests_history[client_ip]
                if current_time - t <= self.window_seconds
            ]
            self.requests_history[client_ip] = valid_timestamps

            # Перевіряємо перевищення ліміту запитів
            if len(valid_timestamps) >= self.limit:
                return JSONResponse(
                    status_code=status.HTTP_429_TOO_MANY_REQUESTS,
                    content={
                        "error": "TOO_MANY_REQUESTS",
                        "message": f"Перевищено ліміт запитів: максимум {self.limit} запитів за {self.window_seconds} секунд."
                    }
                )

            # Реєструємо поточний запит
            self.requests_history[client_ip].append(current_time)

        return await call_next(request)

# Дозволяємо максимум 3 запити за 10 секунд
app.add_middleware(SlidingWindowRateLimiter, limit=3, window_seconds=10)

@app.get("/fast-route")
async def fast_route():
    return {"message": "Запит успішно оброблено!"}

# secure_vault_app.py
import time
import uuid
import logging
from contextvars import ContextVar
from fastapi import FastAPI, Request, status, HTTPException
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.trustedhost import TrustedHostMiddleware
from pydantic import BaseModel, Field
from slowapi import Limiter
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded

# 1. Налаштування контексту трасування та логування
correlation_id_var: ContextVar[str] = ContextVar("correlation_id", default="")

logging.basicConfig(level=logging.INFO, format="[%(asctime)s] [ID: %(correlation_id)s] %(message)s")
logger = logging.getLogger("VaultLogger")

class CorrelationIdFilter(logging.Filter):
    def filter(self, record):
        record.correlation_id = correlation_id_var.get()
        return True

logger.addFilter(CorrelationIdFilter())

# 2. Ініціалізація Rate Limiter
limiter = Limiter(key_func=get_remote_address)
app = FastAPI(title="Secure Vault Microservice")
app.state.limiter = limiter

# 3. Визначення доменних помилок
class SecretNotFoundError(Exception):
    def __init__(self, secret_id: str):
        self.secret_id = secret_id

# 4. Реєстрація кастомних обробників виключень
@app.exception_handler(SecretNotFoundError)
async def secret_not_found_handler(request: Request, exc: SecretNotFoundError):
    logger.warning(f"Спроба отримати неіснуючий секрет: {exc.secret_id}")
    return JSONResponse(
        status_code=status.HTTP_404_NOT_FOUND,
        content={
            "error": "SECRET_NOT_FOUND",
            "message": f"Секрет із ідентифікатором '{exc.secret_id}' не знайдено в системі.",
            "details": {"requested_id": exc.secret_id}
        }
    )

@app.exception_handler(RateLimitExceeded)
async def rate_limit_exceeded_handler(request: Request, exc: RateLimitExceeded):
    logger.warning("Клієнт перевищив ліміт запитів!")
    return JSONResponse(
        status_code=status.HTTP_429_TOO_MANY_REQUESTS,
        content={
            "error": "TOO_MANY_REQUESTS",
            "message": "Ви надсилаєте забагато запитів. Будь ласка, зачекайте.",
            "limit": exc.detail
        }
    )

# 5. Підключення посередника трасування (Correlation ID)
@app.middleware("http")
async def add_correlation_id(request: Request, call_next):
    corr_id = request.headers.get("X-Correlation-ID", str(uuid.uuid4()))
    token = correlation_id_var.set(corr_id)

    start_time = time.perf_counter()
    logger.info(f"Запит: {request.method} {request.url.path}")

    try:
        response = await call_next(request)
    finally:
        process_time = time.perf_counter() - start_time
        logger.info(f"Відповідь: {request.method} {request.url.path} | Статус: {response.status_code} | Час: {process_time:.4f}s")
        response.headers["X-Correlation-ID"] = corr_id
        correlation_id_var.reset(token)

    return response

# 6. Налаштування TrustedHostMiddleware
app.add_middleware(
    TrustedHostMiddleware,
    allowed_hosts=["localhost", "127.0.0.1"]
)

# 7. Налаштування CORSMiddleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://vault-spa.com"],  # Тільки дозволений SPA-домен
    allow_credentials=True,
    allow_methods=["GET", "POST", "OPTIONS"],
    allow_headers=["Content-Type", "Authorization", "X-Correlation-ID"],
)

# 8. Схеми даних Pydantic
class SecretCreate(BaseModel):
    title: str = Field(..., min_length=3, max_length=100)
    payload: str = Field(..., description="Зашифрований вміст секрету")

class SecretResponse(BaseModel):
    id: str
    title: str
    payload: str

# Симульована база даних у пам'яті
VAULT_DB: dict[str, dict] = {}

# 9. Маршрути додатку
@app.post("/secrets", response_model=SecretResponse, status_code=status.HTTP_201_CREATED)
async def create_secret(secret: SecretCreate):
    secret_id = str(uuid.uuid4())[:8]  # Короткий ID для зручності демонстрації
    new_secret = {
        "id": secret_id,
        "title": secret.title,
        "payload": secret.payload
    }
    VAULT_DB[secret_id] = new_secret
    logger.info(f"Створено новий секрет з ID: {secret_id}")
    return new_secret

@app.get("/secrets/{id}", response_model=SecretResponse)
@limiter.limit("5/minute")
async def get_secret(id: str, request: Request):
    logger.info(f"Запит на отримання секрету: {id}")
    if id not in VAULT_DB:
        raise SecretNotFoundError(id)
    return VAULT_DB[id]

# app/core/exceptions.py

class DomainException(Exception):
    """Базове доменне виключення для всього додатка TaskForge"""
    def __init__(self, message: str, code: str):
        self.message = message
        self.code = code
        super().__init__(self.message)

class ProjectNotFoundError(DomainException):
    def __init__(self, project_id: int):
        super().__init__(
            message=f"Проєкт із ідентифікатором {project_id} не знайдено.",
            code="PROJECT_NOT_FOUND"
        )

class TaskNotFoundError(DomainException):
    def __init__(self, task_id: int):
        super().__init__(
            message=f"Таску з ідентифікатором {task_id} не знайдено.",
            code="TASK_NOT_FOUND"
        )

class ForbiddenError(DomainException):
    def __init__(self, action: str):
        super().__init__(
            message=f"У вас немає прав для виконання дії: {action}.",
            code="ACCESS_FORBIDDEN"
        )

# main.py
import time
import uuid
import logging
from contextvars import ContextVar
from fastapi import FastAPI, Request, status
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware

# Імпортуємо доменні помилки
from app.core.exceptions import DomainException, ProjectNotFoundError, ForbiddenError

# Налаштовуємо контекст Correlation ID
correlation_id_var: ContextVar[str] = ContextVar("correlation_id", default="")
logging.basicConfig(level=logging.INFO, format="[%(asctime)s] [ID: %(correlation_id)s] %(message)s")
logger = logging.getLogger("TaskForgeLogger")

class CorrelationIdFilter(logging.Filter):
    def filter(self, record):
        record.correlation_id = correlation_id_var.get()
        return True

logger.addFilter(CorrelationIdFilter())

app = FastAPI(
    title="TaskForge API",
    description="Система управління проєктами та тасками"
)

# 1. Глобальний обробник доменних помилок
@app.exception_handler(DomainException)
async def domain_exception_handler(request: Request, exc: DomainException):
    status_code = status.HTTP_400_BAD_REQUEST

    if "NOT_FOUND" in exc.code:
        status_code = status.HTTP_404_NOT_FOUND
    elif "ACCESS_FORBIDDEN" in exc.code:
        status_code = status.HTTP_403_FORBIDDEN

    logger.warning(f"Доменне виключення [{exc.code}] на {request.method} {request.url.path}: {exc.message}")

    return JSONResponse(
        status_code=status_code,
        content={
            "error": exc.code,
            "message": exc.message,
            "details": None
        }
    )

# 2. Посередник трасування Correlation ID та часу виконання
@app.middleware("http")
async def audit_logging_middleware(request: Request, call_next):
    corr_id = request.headers.get("X-Correlation-ID", str(uuid.uuid4()))
    token = correlation_id_var.set(corr_id)

    start_time = time.perf_counter()
    logger.info(f"TaskForge запит: {request.method} {request.url.path}")

    try:
        response = await call_next(request)
    finally:
        process_time = time.perf_counter() - start_time
        logger.info(f"TaskForge відповідь: {request.method} {request.url.path} | Статус: {response.status_code} | Час: {process_time:.4f}s")
        response.headers["X-Correlation-ID"] = corr_id
        correlation_id_var.reset(token)

    return response

# 3. Конфігурація CORS для локальної розробки SPA
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],  # Дозволяємо SPA на Nuxt/React
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Простий приклад маршруту для демонстрації
@app.get("/projects/{project_id}")
async def get_project(project_id: int):
    # Симулюємо помилку "не знайдено" для демонстрації роботи обробника
    if project_id == 999:
        raise ProjectNotFoundError(project_id)
    return {"id": project_id, "name": "Демонстраційний проєкт TaskForge"}