Show and tell: Wireup - Type-safe Dependency Injection for Django Ninja

[maldoinc]

I’ve been building Wireup, a Dependency Injection library with Django integration that works with Django Ninja

Why use Dependency Injection?

Key features:

• Type-safe injection via Injected[Service]
• Async-first design with proper resource cleanup (connection pooling, teardown etc)
• Request-scoped services that live for the request lifecycle with per-request isolation
• Injection via @inject decorator in views, serializers. You can inject anywhere in the request path
• Automatic dependency graph resolution - add dependencies without changing callers
• Full feature list

1. Setup

from wireup.integration.django import WireupSettings

INSTALLED_APPS = [
    # ...
    "wireup.integration.django",
]

MIDDLEWARE = [
    "wireup.integration.django.wireup_middleware",
    # ...
]

WIREUP = WireupSettings(
    injectables=["myapp.services"],   # module containing @injectable definitions
)

WEATHER_API_KEY = "..."

2. Define Services

from typing import Annotated, AsyncIterator

import aiohttp
from django.http import HttpRequest
from wireup import Inject, injectable

# Scoped lifetime: One instance per request, shared in that request.
@injectable(lifetime="scoped")
class AuthService:
    def __init__(self, request: HttpRequest) -> None:
        self.request = request

# Singleton (default): One instance per application
@injectable
class WeatherService:
    def __init__(
        self,
        client: aiohttp.ClientSession,
        auth: AuthService,
        api_key: Annotated[str, Inject(config="WEATHER_API_KEY")],
    ) -> None:
        self.client = client
        self.auth = auth
        self.api_key = api_key

    async def forecast(self, city: str) -> dict[str, str]:
        if self.auth.authorized("forecast"):
            return {"city": city, "summary": "sunny"}
        raise UnauthorizedError


# You can also use generator factories to create services if
# special initialization/cleanup is required
@injectable
async def http_client() -> AsyncIterator[aiohttp.ClientSession]:
    connector = aiohttp.TCPConnector(limit=100, ttl_dns_cache=300)
    timeout = aiohttp.ClientTimeout(total=10)
    async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
        yield session

3. Use in views

from ninja import Router, Schema
from wireup import Injected
from wireup.integration.django import inject

from myapp.services import WeatherService

router = Router()


class ForecastOut(Schema):
    city: str
    summary: str
    source_path: str


@router.get("/forecast", response=ForecastOut)
@inject
async def get_forecast(request, city: str, weather: Injected[WeatherService]):
    return await weather.forecast(city)

4. Use anywhere in the request path

from rest_framework import serializers
from wireup import Injected
from wireup.integration.django import inject

from myapp.services import CouponService
from myapp.models import Order


class CheckoutSerializer(serializers.Serializer):
    sku = serializers.CharField()
    qty = serializers.IntegerField(min_value=1)
    coupon = serializers.CharField(required=False, allow_blank=True)

    @inject
    def validate(
        self,
        attrs: dict,
        coupons: Injected[CouponService],
    ) -> dict:
        code = attrs.get("coupon")
        if code and not coupons.is_valid(code, attrs["sku"]):
            raise serializers.ValidationError({"coupon": "Invalid coupon for this SKU"})
        return attrser_created", order_id=order.id)
        return order

---

How are you currently handling dependency management and testing in your Django Ninja projects? Would love to hear what's working (or not working) for others.

• Repository: https://github.com/maldoinc/wireup
• Documentation: https://maldoinc.github.io/wireup/
• Django/Ninja documentation: https://maldoinc.github.io/wireup/latest/integrations/django/