# Copilot için Ayrıntılı Prompt: Django 6.0 Custom Account + Djoser + JWT + Social Auth

Aşağıdaki metni **Copilot Chat** veya GitHub Copilot’a vereceğim. Sen (Copilot) bu projede adım adım ilerleyen bir **backend mimarı + uygulayıcı** gibi davranacaksın.

## Proje Bağlamı

- Framework: **Django==6.0**
- API: **Django REST Framework (djangorestframework==3.16.1)**
- Auth:
  - **Djoser==2.3.3**
  - **djangorestframework_simplejwt==5.5.1**
  - Ek olarak **social auth** social-auth-app-django==5.6.0 social-auth-core==4.8.1 bunlar kulanilacak
- Bu proje bir **REST backend** olacak ve **Nuxt.js** ile **Next.js** frontendlere servis verecek.
  - SPA (Single Page App) + JWT kullanımına uygun olacak.
  - CORS, JSON response formatı, JWT bearer token desteği önemli.(Corsheader Paketi yuklu ve yaplandirlmis)

## İstediğim Auth Sistemi (Özet)

1. **Custom User Model** (email tabanlı):
   - Login **email ile** yapılacak (username yok).
   - Register da email + password ile olacak.
   - `AUTH_USER_MODEL` olarak özel bir user modeli (örn. `accounts.CustomUser`) kullanılacak.
   - `USERNAME_FIELD = "email"`
   - `email` unique olacak.
   - Normal (email/password) register ile oluşturulan hesaplar:
     - Başlangıçta `is_active = False` olacak.
     - Kullanıcı e‑posta aktivasyonu yapmadan giriş yapamayacak.
   - **Social login** ile gelen hesaplar:
     - `is_active = True` olacak (yani sosyal hesaplar için ayrıca email aktivasyon istemeyeceğiz).

2. **Register Akışı (Email/Password)**:
   - Örnek endpoint (Djoser varsayılanı da olabilir): `POST /auth/register/`
   - Request body:
     ```json
     {
       "email": "user@example.com",
       "password": "StrongP@ssw0rd",
       "re_password": "StrongP@ssw0rd",
       "first_name": "Ali",
       "last_name": "Veli"
     }
     ```
   - İşleyiş:
     - Yeni user oluşturulur, `is_active = False` atanır.
     - Djoser üzerinden aktivasyon e‑postası gönderilir.
     - Aktivasyon linki Djoser’in `ACTIVATION_URL` formatına göre hazırlanır:
       - Örn: `https://frontend-domain/auth/activate/{uid}/{token}/` (Nuxt/Next içindeki sayfaya yönlenebilir).

3. **Email Aktivasyon**:
   - Endpoint (Djoser): `POST /auth/activate/`
   - Request body:
     ```json
     {
       "uid": "<uid_from_email>",
       "token": "<token_from_email>"
     }
     ```
   - Aktivasyon başarılı olursa:
     - `user.is_active = True`
     - Kullanıcı artık JWT ile login olabilecek.

4. **Login (JWT ile)**:
   - JWT auth için `djangorestframework_simplejwt` kullanılacak.
   - Djoser’la entegre endpoint:
     - `POST /auth/jwt/create/`
   - Request body:
     ```json
     {
       "email": "user@example.com",
       "password": "StrongP@ssw0rd"
     }
     ```
   - Response:
     ```json
     {
       "access": "<jwt_access_token>",
       "refresh": "<jwt_refresh_token>"
     }
     ```
   - **Aktivasyon yapmamış** kullanıcı login olmaya çalışırsa:
     - Uygun bir hata kodu (400/401) ve anlamlı bir hata mesajı dönecek:
       - Örn: `"detail": "Account is not activated. Please check your email."`

5. **Social Login**:
   - Özel social auth endpoint’leri istiyorum:
     - Örnek: `POST /auth/social/<provider>/` (ör: `/auth/social/google/`, `/auth/social/github/`).
   - Frontend (Nuxt/Next) tarafı:
     - Genelde OAuth flow’u client-side yapıp backend’e `access_token` gönderiyor.
   - Backend tarafı:
     - Provider’dan gelen `access_token` ile kullanıcı bilgisi alınacak.
     - Provider’dan email alınamazsa, uygun bir hata dönülecek (misal: `"Email not provided by provider"`).
     - Eğer email varsa:
       - Kullanıcı bulunursa giriş yaptır, yoksa yeni bir kullanıcı oluştur.
       - Bu kullanıcı için:
         - `is_active = True` olarak set edilecek.
         - **Ekstra email aktivasyon e‑postası gönderilmeyecek**.
       - Ardından JWT access/refresh token üret ve response olarak dön:
         ```json
         {
           "access": "<jwt_access_token>",
           "refresh": "<jwt_refresh_token>",
           "user": {
             "id": 1,
             "email": "user@example.com",
             "first_name": "Ali",
             "last_name": "Veli"
           }
         }
         ```

6. **Djoser Yapılandırması**:
   - `djoser==2.3.3` kullanılacak.
   - `settings.py` içinde `DJOSER = { ... }` konfigürasyonu yapılacak.
   - Örnek ayarlar:
     - `SEND_ACTIVATION_EMAIL = True`
     - `ACTIVATION_URL = "auth/activate/{uid}/{token}/"` (buraya Nuxt/Next üzerindeki route’u da koyabiliriz).
     - `SERIALIZERS` içinde:
       - `user_create` → custom serializer (register sırasında `is_active=False` ayarlayacak).
       - `user` → custom user serializer (frontend’e gönderilecek user alanlarını kontrol etmek için).
     - Token modeli kullanmayacaksak `TOKEN_MODEL = None` vs.

7. **JWT Ayarları (SIMPLE_JWT)**:
   - `REST_FRAMEWORK` → `DEFAULT_AUTHENTICATION_CLASSES` içinde `rest_framework_simplejwt.authentication.JWTAuthentication` tanımlanacak.
   - `SIMPLE_JWT` içinde access/refresh lifetime, `AUTH_HEADER_TYPES = ("Bearer",)` vb. ayarları yapacağız.

8. **Email Gönderimi**:
   - Geliştirme ortamı:
     - `EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"` olabilir.
   - Prod ortamı:
     - ENV üzerinden SMTP ayarları (`EMAIL_HOST`, `EMAIL_PORT`, `EMAIL_HOST_USER`, `EMAIL_HOST_PASSWORD`, `EMAIL_USE_TLS` vb.)
   - Aktivasyon için HTML ve plain text template’leri:
     - `templates/email/activation_email.html`
     - `templates/email/activation_email.txt`
     - sindilik localdeki emailpit kullanalim

9. **CORS / SPA Entegrasyonu**:
   - Nuxt ve Next için:
     - `CORS_ALLOWED_ORIGINS` içinde dev ve prod URL’ler olacak (örn. `http://localhost:3000`, `http://localhost:5173`, vs.).
   - Auth:
     - JWT bearer token kullanılacak: `Authorization: Bearer <access_token>`
     - Cookie tabanlı session auth kullanmayacağız (veya minimal). CSRF, SPA senaryosuna göre ayarlanacak / devre dışı bırakılacak (bunu açıklayan bir not yaz).

10. **Güvenlik & Rate Limiting**:
    - Django password validators aktif olacak.
    - Auth endpoint’leri için basic throttling / rate limit ayarları öner ve uygula (ör: DRF throttling).

11. **Testler**:
    - En azından aşağıdakiler için tests yaz:
      - Register → user oluşturuluyor mu, `is_active=False` mi, email aktivasyonu tetikleniyor mu?
      - Activate → doğru uid/token ile aktivasyon başarılı mı? Yanlış ise hata veriyor mu?
      - Login → aktif kullanıcı login olabiliyor mu? Aktif olmayan için hata dönüyor mu?
      - Social login → access_token üzerinden provider’dan user elde ediliyor mu, `is_active=True` ile user oluşturuluyor mu, JWT dönüyor mu?

12. **Dokümantasyon**:
    - Örnek bir doküman dosyası: `AUTH.md` veya `README.md` içinde bir bölüm:
      - Tüm auth endpoint’leri
      - Örnek request/response’lar
      - Nuxt/Next tarafında nasıl kullanılacağına dair ayrintili notlar
      - ENV değişkenleri (email, social provider keys vs.)

## Dosya ve Kod Yapı Planı

Aşağıdakiler bir referans plan; proje yapısına göre isimler uyarlanabilir (örn. `config/settings.py` vs. `project/settings.py`).

- `accounts/models.py`
  - `CustomUser(AbstractBaseUser, PermissionsMixin)`:
    - Alanlar: `email`, `first_name`, `last_name`, `is_staff`, `is_active`, `date_joined` vb.
    - `USERNAME_FIELD = "email"`
    - `REQUIRED_FIELDS = []` (veya first_name/last_name)
  - `CustomUserManager`:
    - `create_user`
    - `create_superuser`

- `accounts/admin.py`
  - Django admin’de custom user’ı `UserAdmin` türeterek kaydet.

- `accounts/serializers.py`
  - `CustomUserCreateSerializer`:
    - Register sırasında kullanılır.
    - `is_active=False` set eder.
  - `CustomUserSerializer`:
    - Kullanıcı profilini döner (id, email, first_name, last_name vb.).
  - `SocialLoginSerializer`:
    - Alanlar: `provider`, `access_token` (ve gerekiyorsa `id_token` vs.).

- `accounts/views.py`
  - Gerekirse:
    - `SocialLoginView` (provider’a göre token doğrulayan, user oluşturan/döndüren, sonra JWT üreten).
    - İsteğe bağlı: `ResendActivationView`.

- `accounts/urls.py`
  - `/auth/social/<provider>/` için route.
  - Djoser url’leri (register/activate/jwt vb.) de burada veya ana `urls.py` içinde include edilebilir.

- `config/settings.py` (veya proje settings dosyası)
  - `INSTALLED_APPS`:
    - `'accounts'`
    - `'rest_framework'`
    - `'djoser'`
    - `'rest_framework_simplejwt'`
    - `'corsheaders'`
    - Social auth için: `'social_django'` veya seçtiğimiz paket.
  - `AUTH_USER_MODEL = "accounts.CustomUser"`
  - `REST_FRAMEWORK` ayarları (`DEFAULT_AUTHENTICATION_CLASSES`, throttling vb.)
  - `SIMPLE_JWT` ayarları
  - `DJOSER` konfigürasyonu
  - `CORS_ALLOWED_ORIGINS`
  - `EMAIL_BACKEND` ve diğer email ayarları
  - Social provider ayarları (`SOCIAL_AUTH_*` veya ilgili konfigler)

- `templates/email/activation_email.html`
- `templates/email/activation_email.txt`

- `requirements.txt`
  - `Django==6.0`
  - `djangorestframework==3.16.1`
  - `djoser==2.3.3`
  - `djangorestframework_simplejwt==5.5.1`
  - `social-auth-app-django` (veya tercih ettiğimiz social auth paketi)
  - `django-cors-headers`

- `tests/test_accounts.py`
  - Yukarıda bahsettiğim tüm kritik akışlar için testler.

## Hafıza / Progress Kaydı: COPILOT_MEMORY.md

Projede ne yapıldığını **hatırlamak** için özel bir dosya istiyorum:

- Repo kökünde: `COPILOT_MEMORY.md`
- Copilot, her önemli adım veya mantıklı grup değişiklikten sonra bu dosyaya **append** yapsın.
- Kayıt formatı şöyle olsun (örnek):

```markdown
## 2025-12-11T14:32:00Z
- Değişiklik özeti:
  - CustomUser model ve manager eklendi.
  - settings.py'de AUTH_USER_MODEL ve djoser/jwt ayarlarının temeli kuruldu.
- Dosyalar:
  - accounts/models.py
  - accounts/admin.py
  - config/settings.py
- Next steps:
  - Custom registration serializer ve activation email şablonlarını ekle.
```

Kurallar:
- Her anlamlı değişiklik setinden sonra yeni bir `## <ISO 8601 timestamp>` başlığı ile blok ekle.
- Bir sonraki yapılacakları (Next steps) kısa ve net yaz.
- Eğer PR açıyorsan, ilgili PR açıklamasına bu kaydın kısa özetini de ekle.

## Geliştirme Adımları (Önerilen Sıra)

Copilot’tan beklediğim ilerleme sırası:

1. **Custom User Model**
   - `accounts` app oluştur (yoksa).
   - `CustomUser` ve `CustomUserManager` yaz.
   - `AUTH_USER_MODEL` ayarla.
   - Migrasyonları oluştur ve çalıştırılabilir hale getir (kod olarak migration dosyaları üret).

2. **Temel Settings Konfigürasyonu**
   - `INSTALLED_APPS`, `REST_FRAMEWORK`, `SIMPLE_JWT`, `DJOSER`, `CORS`, `EMAIL_BACKEND` vs. temel ayarlar.
   - Nuxt/Next için örnek CORS domainleri koy (yorum satırı olarak da olabilir).

3. **Djoser Register / Activate / JWT**
   - Djoser’ın default endpoint’lerini aktif et.
   - `CustomUserCreateSerializer`’ı bağla, register sırasında `is_active=False` olsun.
   - Aktivasyon URL’ini Nuxt/Next kullanacak şekilde düzenle.

4. **Social Auth Entegrasyonu**
   - Seçilecek social auth paketini netleştir (preferans: `social-auth-app-django`).
   - Provider konfigleri için env örnekleri yaz.
   - `SocialLoginView` ve `SocialLoginSerializer` ile:
     - Provider token doğrulama
     - Email ile user bul/oluştur
     - `is_active=True` set et
     - JWT üret ve dön.

5. **Email Şablonları**
   - Aktivasyon e-postası için HTML ve text template’leri yaz.

6. **Testler**
   - Temel testler: register, activate, login, social login.

7. **Dokümantasyon**
   - `AUTH.md` veya README’ye auth bölümünü ekle.

8. **COPILOT_MEMORY.md Güncellemeleri**
   - Her adımda bu dosyaya not düş.

## Copilot’a Komutum

Bu prompt’u aldıktan sonra, lütfen:

1. Projeyi ve hedefleri özetle.
2. Social auth kütüphanesi seçimi için bana 1–2 öneri sun (örnek: `social-auth-app-django` vs `django-allauth`), artılarını/eksilerini kısaca yaz ve **hangisini seçmek istediğimi sor**.
3. Ben seçimi yaptıktan sonra şu adımla başla:
   - CustomUser model ve manager’ı yaz.
   - `settings.py` içinde gerekli temel konfigürasyonları ekle (AUTH_USER_MODEL, Djoser, DRF, JWT, CORS, EMAIL).
   - `COPILOT_MEMORY.md` dosyasına ilk kaydı ekle.
4. Her büyük adım sonunda:
   - Hangi dosyaları değiştirdiğini kısaca özetle.
   - `COPILOT_MEMORY.md`’ye uygun formatta giriş ekle.
   - Bir sonraki adımı bana öner ve onayımı bekle (veya devam etmemi iste).

Başlangıç komutum:

> **Başla**:  
> - CustomUser model ve manager oluştur.  
> - `settings.py` gerekli auth (Djoser + JWT + DRF + CORS + EMAIL) konfigürasyonlarını ekle.  
> - Djoser’ın register/activate/jwt endpointlerini temel haliyle ayağa kaldıracak url ve ayarları hazırla.  
> - `COPILOT_MEMORY.md` dosyasına başlangıç girdisini ekle.  

Bu prompt’u anladıysan, önce kısaca özetle, sonra social auth kütüphane tercihi için benden seçim iste ve ardından adım 1’e başla.