Vad är API Resources?

Question

Accepted Answer

**API Resources** är transformationsklasser som kontrollerar hur Eloquent-modeller (och samlingar) **serialiseras till JSON** för API-svar. De låter dig forma API-utmatningen precis — välja vilka fält som ska exponeras, döpa dem om, formatera värden och inkludera relaterad data — och frikoppla API-representationen från databasstrukturen.

## Problemet: exponera råa modeller

```php
// ❌ returning a model directly exposes ALL columns (maybe including sensitive ones)
return User::find($id);   // { id, name, email, password_hash, internal_notes, ... } 😱
```

## Lösningen: en API Resource

```php
<?php
// php artisan make:resource UserResource
class UserResource extends JsonResource {
    public function toArray($request): array {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            // password and internal fields deliberately OMITTED
            'joined' => $this->created_at->toDateString(),   // format a value
            'is_admin' => (bool) $this->is_admin,
            // include related data (conditionally loaded)
            'posts' => PostResource::collection($this->whenLoaded('posts')),
        ];
    }
}
```

```php
// use it in a controller
return new UserResource($user);                  // a single model
return UserResource::collection(User::all());     // a collection
```

Resourcens `toArray()` definierar exakt JSON-formen — du kontrollerar vilka fält som visas, döper om och formaterar dem, och inkluderar relaterade resources. Känsliga fält är helt enkelt inte inkluderade.

## Villkorlig och kapslad data

```php
return [
    'id' => $this->id,
    'secret' => $this->when($request->user()->isAdmin(), $this->secret),  // conditional field
    'posts' => PostResource::collection($this->whenLoaded('posts')),       // only if eager-loaded
];
```

## Varför det är viktigt

API Resources är viktiga för att bygga väldesignade, säkra API:er i Laravel — de ger dig exakt kontroll över JSON-utmatning, vilket är viktigt för både **säkerhet** och API-design.

Den viktigaste fördelarna är **att förhindra datalakning**: att returnera Eloquent-modeller direkt exponerar alla deras kolumner (potentiellt inklusive lösenordshashningar, interna flaggor eller annan känslig data — en allvarlig säkerhetsbrist), medan API Resources låter dig explicit välja vilka fält som ska exponeras, vilket säkerställer att känslig data aldrig når klienter.

Utöver säkerhet möjliggör de ren API-design genom att **frikoppla API-representationen från databasschemat** — du kan döpa om fält, formatera värden (datum, booleaner), strukturera kapslad/relaterad data och villkorligt inkludera fält baserat på behörigheter, allt i en dedikerad transformationsklass.

Detta håller API-kontraktet stabilt och avsiktligt snarare än kopplat till intern tabellstruktur.

Att förstå API Resources — hur de formar JSON-utmatning, säkerhetsfördelen med explicit fältkontroll och funktioner som villkorliga fält och kapslade resources — är viktig kunskap för att bygga professionella Laravel-API:er, eftersom exponering av råa modeller är både osäker och dålig design.

Då REST/JSON-API:er är en primär användning av Laravel idag, och eftersom kontroll av svarsform (säkert och rent) är ett vanligt, viktigt behov, är API Resources ett ofta använt, värdefullt verktyg som skiljer väl byggda, säkra API:er från sådana som läcker data eller tätt kopplar sin utmatning till databasen.