api-sdk-generator

Files (1)

• SKILL.md

SKILL.md (first lines)

# API SDK & Codegen Skill
## When to Use

Use this skill when you need generates client SDK code, API wrapper libraries, request/response models, and language-specific usage patterns for any REST API. Use whenever the user asks to "generate an SDK", "write a client library", "create API wrappers", "generate TypeScript types from my API", "write a Python...


Generate API-specific client drafts; production readiness requires the actual contract, tests and target-language review.

---

## SDK Structure (any language)

```
sdk/
├── client.{ext}          — main client class with base URL, auth, retry
├── resources/
│   ├── users.{ext}       — one file per API resource
│   ├── orders.{ext}
│   └── ...
├── models/
│   ├── user.{ext}        — request/response data models
│   └── ...
├── errors.{ext}          — typed error classes
└── utils/
    ├── retry.{ext}
    └── pagination.{ext}
```

---

## Base Client Pattern

### Python
```python
import httpx
from typing import Optional
import time

class APIClient:
    def __init__(self, api_key: str, base_url: str = "https://api.example.com/v1"):
        self.base_url = base_url
        self._headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
            "User-Agent": "example-sdk-python/1.0.0"
        }
        self._client = httpx.Client(timeout=30.0)

    def _request(self, method: str, path: str, **kwargs) -> dict:
        url = f"{self.base_url}{path}"
        # No automatic replay of writes: add bounded retries only for operations
        # documented as safe/idempotent, with API-supported idempotency keys.
        resp = self._client.request(method, url, headers=self._headers, **kwargs)
        if resp.is_error:
            raise APIError(resp.status_code, "Request failed")  # redact bodies/secrets
        if resp.status_code == 204 or not resp.content:
            return None
        return resp.json()  # validate against the endpoint response schema

    def close(self):
        self._client.close()

```

### TypeScript
```typescript
class APIClient {
  private readonly baseUrl: string;
  private readonly headers: Record<string, string>;

  constructor(apiKey: string, baseUrl = 'https://api.example.com/v1') {
    this.baseUrl = baseUrl;
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    };
  }

  async request<T>(method: string, path: string, body?: unknown): Promise<T> {
    const res = await fetch(`${this.baseUrl}${path}`, {
      method,
      headers: this.headers,
      body: body !== undefined ? JSON.stringify(body) : undefined,
      signal: AbortSignal.timeout(30_000),
    });
    if (!res.ok) {
      throw new Error(`API request failed: HTTP ${res.status}`);
    }
    if (res.status === 204) return undefined as T;
    return await res.json() as T; // A cast is not runtime schema validation.
  }
}
```

---

## Resource Class Pattern

### Python
```python
from dataclasses import dataclass
from typing import Optional, List

@dataclass
class User:
    id: str
    name: str
    email: str
    created_at: str
    role: Optional[str] = None

class UsersResource:
    def __init__(self, client: APIClient):
        self._client = client

    def list(self, page: int = 1, limit: int = 20) -> List[User]:
        data = self._client._request("GET", f"/users?page={page}&limit={limit}")
        return [User(**u) for u in data["data"]]

From sickn33/agentic-awesome-skills, MIT.

More from sickn33/agentic-awesome-skills