---
title: Scope Değişikliklerini Yönetme
description: Yeni özellikler için yeniden yetkilendirme sürecinin yönetimi
---

Uygulamanıza yeni özellik eklediğinizde yeni yetkiler gerekebilir. Örneğin siparişleri listelemek için `read_orders` veya güncellemek için `write_orders` yetkisi gerekir. OAuth scope'unu güncellemek için uygulamanızı yeniden yetkilendirmelisiniz.

## Yeniden Yetkilendirme Kontrolü

Mevcut scope'ları kontrol eden ve gerekirse yeniden yetkilendirme başlatan API oluşturalım.

`app/api/oauth/check-for-reauthorize/route.ts` dosyasını oluşturun:

```typescript title="File: app/api/oauth/check-for-reauthorize/route.ts"
import { NextRequest, NextResponse } from 'next/server';
import { ensureLoggedIn } from '@/lib/ensure-logged-in';
import { config } from '@/globals/config';
import { getIkas } from '@/lib/ikas-api';
import { RedisDB } from '@/lib/redis';

export type CheckForReauthorizeResponse = {
  required: boolean;
  authorizeData?: {
    redirectUri: string;
    scope: string;
    state: string;
  };
};

export async function GET(request: NextRequest) {
  try {
    const user = await ensureLoggedIn(request);
    if (!user) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }

    const token = await RedisDB.token.get(user.authorizedAppId);
    if (!token) {
      return NextResponse.json({ error: 'Token not found' }, { status: 404 });
    }

    const ikasClient = getIkas(token);
    const meRes = await ikasClient.adminApi.queries.me({});

    if (meRes.isSuccess && meRes.data) {
      // Scope'ları karşılaştır
      if (meRes.data.scope !== config.scope) {
        const state = Math.random().toFixed(16);
        await RedisDB.state.set(state, state, 60);

        return NextResponse.json({
          required: true,
          authorizeData: {
            state,
            scope: config.scope,
            redirectUri: config.callbackUrl,
          },
        });
      }
    }

    return NextResponse.json({ required: false });
  } catch (error: any) {
    console.error('Reauthorize check error:', error);
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}
```

## API Request Helper

`lib/api-requests.ts` dosyasını güncelleyin:

```typescript
import { CheckForReauthorizeResponse } from '@/app/api/oauth/check-for-reauthorize/route';

export const ApiRequests = {
  getTokenWithSignature: (data: GetTokenWithSignatureApiRequest) => 
    makePostRequest<GetTokenWithSignatureApiResponse>({ 
      url: '/api/get-token-with-signature', 
      data 
    }),
  oauth: {
    checkForReauthorize: (token: string) => 
      makeGetRequest<CheckForReauthorizeResponse>({ 
        url: '/api/oauth/check-for-reauthorize', 
        token 
      }),
  },
};
```

## Ana Sayfada Scope Kontrolü

`app/page.tsx` dosyasının `load` fonksiyonunu güncelleyin:

```typescript title="File: app/page.tsx"
const load = async () => {
  AppBridgeHelper.closeLoader();
  const params = new URLSearchParams(window.location.search);
  
  // Token al - iframe veya external
  let token = await TokenHelpers.getTokenForIframeApp(router);
  let isInternallyLoaded = false;
  
  if (token) {
    isInternallyLoaded = true;
  } else {
    token = await TokenHelpers.getTokenForExternalApp(router, params);
  }

  if (token) {
    // Yeniden yetkilendirme kontrolü
    const res = await ApiRequests.oauth.checkForReauthorize(token);
    const data = res.data as CheckForReauthorizeResponse | undefined;
    
    if (data?.required) {
      if (isInternallyLoaded) {
        // ikas dashboard içinde - AppBridge kullan
        AppBridgeHelper.reAuthorizeApp(data.authorizeData!);
      } else {
        // External - authorize API'sine yönlendir
        const storeName = params.get('storeName');
        window.location.replace(`/api/oauth/authorize?storeName=${storeName}`);
      }
    } else {
      // Scope güncel - dashboard'a git
      await router.push('/dashboard');
    }
  }
};
```

## AppBridge Helper Güncelleme

`lib/app-bridge-helper.ts` dosyasına `reAuthorizeApp` fonksiyonunu ekleyin:

```typescript
export class AppBridgeHelper {
  static reAuthorizeApp(authorizeData: {
    redirectUri: string;
    scope: string;
    state: string;
  }) {
    if (typeof window !== 'undefined' && window.parent) {
      window.parent.postMessage({
        type: 'RE_AUTHORIZE_APP',
        data: authorizeData,
      }, '*');
    }
  }
}
```

## Akış Açıklaması

### 1. Scope Kontrolü
Token alındıktan sonra `checkForReauthorize` API'si çağrılır ve mevcut scope ile uygulama scope'u karşılaştırılır.

### 2. Yeniden Yetkilendirme
Scope değiştiğinde:
- **iframe içinde**: `AppBridgeHelper.reAuthorizeApp()` ile ikas dashboard yetki sayfasına yönlenir
- **External**: Doğrudan `/api/oauth/authorize` API'sine redirect edilir

### 3. Tamamlama
Yeni yetkileri onaylayınca callback API çağrılır ve güncel token kaydedilir.

<Callout type="warning" title="Önemli Not">
Scope değişikliği yapıldığında tüm mağaza sahipleri uygulamanıza yeniden yetki vermelidir. Bu durum kullanıcı deneyimini etkileyebilir.
</Callout>