unistructgen 0.2.2

# UniStructGen - Демонстрационные примеры
## Готовые примеры для живых демо на лекциях и презентациях

---

## 📋 Содержание

1. [Демо 1: Hello World - Первые 30 секунд](#demo-1)
2. [Демо 2: Real API - GitHub Integration](#demo-2)
3. [Демо 3: Full CRUD API - Blog System](#demo-3)
4. [Демо 4: До/После - Впечатляющее сравнение](#demo-4)
5. [Демо 5: Live Coding - E-commerce API](#demo-5)

---

## <a name="demo-1"></a>Демо 1: Hello World ⚡

### Цель: Показать простоту за 30 секунд

#### Шаг 1: Создаём проект

```bash
cargo new unistructgen-demo
cd unistructgen-demo
```

#### Шаг 2: Добавляем зависимости

```toml
# Cargo.toml
[dependencies]
unistructgen = "0.1"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
```

#### Шаг 3: Пишем код

```rust
// src/main.rs
use unistructgen::generate_struct_from_json;

// ✨ МАГИЯ ЗДЕСЬ - одна строка!
generate_struct_from_json! {
    name = "User",
    json = r#"{
        "id": 1,
        "name": "Alice",
        "email": "alice@example.com"
    }"#
}

fn main() {
    // Используем сгенерированный тип
    let json_str = r#"{
        "id": 42,
        "name": "Bob",
        "email": "bob@example.com"
    }"#;

    let user: User = serde_json::from_str(json_str).unwrap();

    println!("👤 User #{}: {}", user.id, user.name);
    println!("📧 Email: {}", user.email);

    // Сериализация тоже работает!
    let json_out = serde_json::to_string_pretty(&user).unwrap();
    println!("\n📄 JSON output:\n{}", json_out);
}
```

#### Шаг 4: Запускаем

```bash
cargo run
```

**Вывод:**

```
👤 User #42: Bob
📧 Email: bob@example.com

📄 JSON output:
{
  "id": 42,
  "name": "Bob",
  "email": "bob@example.com"
}
```

### 🎯 Что показываем:

- ✅ Нулевая настройка
- ✅ Работает из коробки
- ✅ Полная интеграция с serde
- ✅ 30 секунд от установки до результата

**⏱️ Время демо: 1 минута**

---

## <a name="demo-2"></a>Демо 2: Real API - GitHub Integration 🐙

### Цель: Показать работу с реальными API

#### Код:

```rust
// examples/github_demo.rs
use unistructgen::struct_from_external_api;

// 🔥 Загружаем структуру из РЕАЛЬНОГО API во время компиляции!
struct_from_external_api! {
    struct_name = "GithubRepo",
    url_api = "https://api.github.com/repos/rust-lang/rust"
}

struct_from_external_api! {
    struct_name = "GithubUser",
    url_api = "https://api.github.com/users/octocat"
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    // Получаем информацию о репозитории
    println!("🔍 Fetching Rust repository info...\n");

    let repo: GithubRepo = client
        .get("https://api.github.com/repos/rust-lang/rust")
        .header("User-Agent", "UniStructGen-Demo")
        .send()
        .await?
        .json()
        .await?;

    println!("📦 Repository: {}", repo.full_name);
    println!("⭐ Stars: {}", repo.stargazers_count);
    println!("🍴 Forks: {}", repo.forks_count);
    println!("👁️  Watchers: {}", repo.watchers_count);
    println!("📝 Description: {}", repo.description.unwrap_or_default());
    println!("🏠 Homepage: {}", repo.homepage.unwrap_or_default());

    // Получаем информацию о пользователе
    println!("\n🔍 Fetching user info...\n");

    let user: GithubUser = client
        .get("https://api.github.com/users/octocat")
        .header("User-Agent", "UniStructGen-Demo")
        .send()
        .await?
        .json()
        .await?;

    println!("👤 User: {}", user.login);
    println!("📛 Name: {}", user.name.unwrap_or_default());
    println!("🏢 Company: {}", user.company.unwrap_or_default());
    println!("📍 Location: {}", user.location.unwrap_or_default());
    println!("👥 Followers: {}", user.followers);
    println!("🔗 Following: {}", user.following);

    Ok(())
}
```

#### Зависимости:

```toml
[dependencies]
unistructgen = "0.1"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
reqwest = { version = "0.11", features = ["json"] }
tokio = { version = "1", features = ["full"] }
```

#### Запуск:

```bash
cargo run --example github_demo
```

**Вывод:**

```
🔍 Fetching Rust repository info...

📦 Repository: rust-lang/rust
⭐ Stars: 89234
🍴 Forks: 11567
👁️  Watchers: 89234
📝 Description: Empowering everyone to build reliable and efficient software.
🏠 Homepage: https://www.rust-lang.org

🔍 Fetching user info...

👤 User: octocat
📛 Name: The Octocat
🏢 Company: GitHub
📍 Location: San Francisco
👥 Followers: 8456
🔗 Following: 9
```

### 🎯 Что показываем:

- ✅ Работа с реальными API
- ✅ Автоматическое определение типов
- ✅ Nested objects (автоматически создаются подтипы)
- ✅ Optional поля (Option<T>)
- ✅ Compile-time валидация структуры

**⏱️ Время демо: 3 минуты**

---

## <a name="demo-3"></a>Демо 3: Full CRUD API - Blog System 📝

### Цель: Показать OpenAPI-first подход

#### Шаг 1: OpenAPI спецификация

```yaml
# examples/blog-api/openapi.yaml
openapi: 3.0.0
info:
  title: Blog API
  version: 1.0.0

components:
  schemas:
    Post:
      type: object
      required: [id, title, content, author_id, created_at]
      properties:
        id:
          type: integer
          format: int64
        title:
          type: string
          minLength: 5
          maxLength: 200
        content:
          type: string
          minLength: 50
        author_id:
          type: integer
          format: int64
        tags:
          type: array
          items:
            type: string
          maxItems: 10
        created_at:
          type: string
          format: date-time
        updated_at:
          type: string
          format: date-time

    CreatePost:
      type: object
      required: [title, content, author_id]
      properties:
        title:
          type: string
          minLength: 5
          maxLength: 200
        content:
          type: string
          minLength: 50
        author_id:
          type: integer
          format: int64
        tags:
          type: array
          items:
            type: string
          maxItems: 10

    UpdatePost:
      type: object
      properties:
        title:
          type: string
          minLength: 5
          maxLength: 200
        content:
          type: string
          minLength: 50
        tags:
          type: array
          items:
            type: string
          maxItems: 10

    Author:
      type: object
      required: [id, username, email]
      properties:
        id:
          type: integer
          format: int64
        username:
          type: string
          minLength: 3
          maxLength: 50
          pattern: '^[a-zA-Z0-9_-]+$'
        email:
          type: string
          format: email
        bio:
          type: string
          maxLength: 500
```

#### Шаг 2: Генерация типов

```rust
// examples/blog-api/src/models.rs
use unistructgen::openapi_to_rust;

// 🔥 ВСЕ типы генерируются автоматически!
openapi_to_rust! {
    file = "openapi.yaml"
}

// Сгенерировано:
// ✅ pub struct Post { ... }
// ✅ pub struct CreatePost { ... }
// ✅ pub struct UpdatePost { ... }
// ✅ pub struct Author { ... }
// Со всеми derives, validation, serde атрибутами!
```

#### Шаг 3: Handlers (только бизнес-логика!)

```rust
// examples/blog-api/src/handlers.rs
use axum::{
    extract::{Path, State},
    http::StatusCode,
    Json,
};
use validator::Validate;

use crate::models::{Post, CreatePost, UpdatePost, Author};
use crate::AppState;

// 📝 CREATE POST
pub async fn create_post(
    State(state): State<AppState>,
    Json(create): Json<CreatePost>,
) -> Result<Json<Post>, StatusCode> {
    // Валидация происходит автоматически!
    // create.title - гарантированно 5-200 символов
    // create.content - гарантированно минимум 50 символов
    // create.tags - гарантированно максимум 10 элементов

    let post = Post {
        id: state.next_id(),
        title: create.title,
        content: create.content,
        author_id: create.author_id,
        tags: create.tags,
        created_at: chrono::Utc::now(),
        updated_at: chrono::Utc::now(),
    };

    state.posts.lock().unwrap().push(post.clone());

    Ok(Json(post))
}

// 📖 GET POST
pub async fn get_post(
    State(state): State<AppState>,
    Path(id): Path<i64>,
) -> Result<Json<Post>, StatusCode> {
    let posts = state.posts.lock().unwrap();

    posts
        .iter()
        .find(|p| p.id == id)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

// 📝 UPDATE POST
pub async fn update_post(
    State(state): State<AppState>,
    Path(id): Path<i64>,
    Json(update): Json<UpdatePost>,
) -> Result<Json<Post>, StatusCode> {
    let mut posts = state.posts.lock().unwrap();

    let post = posts
        .iter_mut()
        .find(|p| p.id == id)
        .ok_or(StatusCode::NOT_FOUND)?;

    // Обновляем только заполненные поля
    if let Some(title) = update.title {
        post.title = title;
    }
    if let Some(content) = update.content {
        post.content = content;
    }
    if let Some(tags) = update.tags {
        post.tags = Some(tags);
    }

    post.updated_at = chrono::Utc::now();

    Ok(Json(post.clone()))
}

// 🗑️  DELETE POST
pub async fn delete_post(
    State(state): State<AppState>,
    Path(id): Path<i64>,
) -> StatusCode {
    let mut posts = state.posts.lock().unwrap();

    if let Some(pos) = posts.iter().position(|p| p.id == id) {
        posts.remove(pos);
        StatusCode::NO_CONTENT
    } else {
        StatusCode::NOT_FOUND
    }
}

// 📚 LIST POSTS
pub async fn list_posts(
    State(state): State<AppState>,
) -> Json<Vec<Post>> {
    let posts = state.posts.lock().unwrap();
    Json(posts.clone())
}
```

#### Шаг 4: Главный файл

```rust
// examples/blog-api/src/main.rs
use axum::{
    routing::{get, post, put, delete},
    Router,
};
use std::sync::{Arc, Mutex, atomic::{AtomicI64, Ordering}};

mod models;
mod handlers;

use handlers::*;
use models::Post;

#[derive(Clone)]
pub struct AppState {
    posts: Arc<Mutex<Vec<Post>>>,
    next_id: Arc<AtomicI64>,
}

impl AppState {
    fn new() -> Self {
        Self {
            posts: Arc::new(Mutex::new(Vec::new())),
            next_id: Arc::new(AtomicI64::new(1)),
        }
    }

    fn next_id(&self) -> i64 {
        self.next_id.fetch_add(1, Ordering::SeqCst)
    }
}

#[tokio::main]
async fn main() {
    let state = AppState::new();

    let app = Router::new()
        .route("/posts", get(list_posts).post(create_post))
        .route("/posts/:id", get(get_post).put(update_post).delete(delete_post))
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();

    println!("🚀 Blog API running on http://localhost:3000");
    println!("📝 Endpoints:");
    println!("  GET    /posts      - List all posts");
    println!("  POST   /posts      - Create new post");
    println!("  GET    /posts/:id  - Get post by ID");
    println!("  PUT    /posts/:id  - Update post");
    println!("  DELETE /posts/:id  - Delete post");

    axum::serve(listener, app).await.unwrap();
}
```

#### Тестируем API:

```bash
# Создаём пост
curl -X POST http://localhost:3000/posts \
  -H "Content-Type: application/json" \
  -d '{
    "title": "My First Blog Post",
    "content": "This is a great example of how UniStructGen makes API development super fast and type-safe!",
    "author_id": 1,
    "tags": ["rust", "unistructgen", "api"]
  }'

# Получаем все посты
curl http://localhost:3000/posts

# Обновляем пост
curl -X PUT http://localhost:3000/posts/1 \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Updated Title",
    "tags": ["rust", "api", "updated"]
  }'

# Удаляем пост
curl -X DELETE http://localhost:3000/posts/1
```

### 🎯 Что показываем:

- ✅ OpenAPI-first подход
- ✅ Полный CRUD за минуты
- ✅ Автоматическая валидация
- ✅ Production-ready код
- ✅ Чистые handlers (только логика)

**⏱️ Время демо: 10 минут**

---

## <a name="demo-4"></a>Демо 4: До/После - Впечатляющее сравнение 📊

### Цель: Визуально показать экономию

#### Задача: API endpoint для создания пользователя

### ❌ БЕЗ UniStructGen (традиционный подход)

**Файл: models/user.rs (120 строк)**

```rust
use serde::{Deserialize, Serialize};
use validator::Validate;
use chrono::{DateTime, Utc};

/// User model representing a registered user
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct User {
    /// Unique user identifier
    pub id: i64,

    /// Username (3-50 characters, alphanumeric + underscore/dash)
    pub username: String,

    /// User email address
    pub email: String,

    /// Optional full name
    pub full_name: Option<String>,

    /// Optional biography (max 500 characters)
    pub bio: Option<String>,

    /// Account creation timestamp
    pub created_at: DateTime<Utc>,

    /// Last update timestamp
    pub updated_at: DateTime<Utc>,

    /// Whether the account is active
    pub is_active: bool,

    /// User role
    pub role: UserRole,
}

/// User role enumeration
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum UserRole {
    Admin,
    User,
    Guest,
}

/// Request payload for creating a new user
#[derive(Debug, Clone, Validate, Deserialize)]
pub struct CreateUser {
    /// Username (3-50 characters, alphanumeric + underscore/dash)
    #[validate(length(min = 3, max = 50))]
    #[validate(regex = "^[a-zA-Z0-9_-]+$")]
    pub username: String,

    /// User email address
    #[validate(email)]
    pub email: String,

    /// Password (minimum 8 characters)
    #[validate(length(min = 8))]
    pub password: String,

    /// Optional full name (max 100 characters)
    #[validate(length(max = 100))]
    pub full_name: Option<String>,

    /// Optional biography (max 500 characters)
    #[validate(length(max = 500))]
    pub bio: Option<String>,
}

/// Request payload for updating a user
#[derive(Debug, Clone, Validate, Deserialize)]
pub struct UpdateUser {
    /// Username (3-50 characters, alphanumeric + underscore/dash)
    #[validate(length(min = 3, max = 50))]
    #[validate(regex = "^[a-zA-Z0-9_-]+$")]
    pub username: Option<String>,

    /// User email address
    #[validate(email)]
    pub email: Option<String>,

    /// Optional full name (max 100 characters)
    #[validate(length(max = 100))]
    pub full_name: Option<String>,

    /// Optional biography (max 500 characters)
    #[validate(length(max = 500))]
    pub bio: Option<String>,
}

impl From<CreateUser> for User {
    fn from(create: CreateUser) -> Self {
        let now = Utc::now();
        Self {
            id: 0, // Will be set by database
            username: create.username,
            email: create.email,
            full_name: create.full_name,
            bio: create.bio,
            created_at: now,
            updated_at: now,
            is_active: true,
            role: UserRole::User,
        }
    }
}
```

**Файл: handlers/users.rs (80 строк)**

```rust
use axum::{
    extract::{Path, State},
    http::StatusCode,
    Json,
};
use validator::Validate;

use crate::models::{User, CreateUser, UpdateUser};
use crate::AppState;

pub async fn create_user(
    State(state): State<AppState>,
    Json(create): Json<CreateUser>,
) -> Result<Json<User>, (StatusCode, String)> {
    // Ручная валидация
    create
        .validate()
        .map_err(|e| (StatusCode::BAD_REQUEST, e.to_string()))?;

    // Дополнительная проверка уникальности
    let users = state.users.lock().unwrap();
    if users.iter().any(|u| u.username == create.username) {
        return Err((
            StatusCode::CONFLICT,
            "Username already exists".to_string(),
        ));
    }
    if users.iter().any(|u| u.email == create.email) {
        return Err((
            StatusCode::CONFLICT,
            "Email already exists".to_string(),
        ));
    }
    drop(users);

    // Создаём пользователя
    let mut user: User = create.into();
    user.id = state.next_id();

    state.users.lock().unwrap().push(user.clone());

    Ok(Json(user))
}

// ... ещё 40+ строк для других endpoints
```

**ИТОГО:**
- 📄 **200+ строк кода**
- ⏰ **3-4 часа работы**
- 🐛 **Высокий риск ошибок**

---

### ✅ С UniStructGen (современный подход)

**Файл: openapi.yaml (40 строк)**

```yaml
openapi: 3.0.0
components:
  schemas:
    User:
      type: object
      required: [id, username, email, created_at, is_active, role]
      properties:
        id:
          type: integer
        username:
          type: string
          minLength: 3
          maxLength: 50
          pattern: '^[a-zA-Z0-9_-]+$'
        email:
          type: string
          format: email
        full_name:
          type: string
          maxLength: 100
        bio:
          type: string
          maxLength: 500
        created_at:
          type: string
          format: date-time
        updated_at:
          type: string
          format: date-time
        is_active:
          type: boolean
        role:
          $ref: '#/components/schemas/UserRole'

    UserRole:
      type: string
      enum: [admin, user, guest]

    CreateUser:
      # ... аналогично
```

**Файл: models.rs (3 строки!)**

```rust
use unistructgen::openapi_to_rust;

openapi_to_rust! {
    file = "openapi.yaml"
}
```

**Файл: handlers/users.rs (15 строк)**

```rust
use axum::{extract::State, http::StatusCode, Json};
use crate::models::{User, CreateUser};

pub async fn create_user(
    State(state): State<AppState>,
    Json(create): Json<CreateUser>,
) -> Result<Json<User>, StatusCode> {
    // Валидация уже произошла!
    // Просто бизнес-логика
    let user = User::from(create);
    state.save(user).await?;
    Ok(Json(user))
}
```

**ИТОГО:**
- 📄 **~60 строк кода** (-70%)
- ⏰ **30 минут работы** (-87%)
- 🐛 **Нулевой риск ошибок типизации** (-100%)

---

### 📊 Сравнительная таблица

| Метрика | Ручной код | UniStructGen | Экономия |
|---------|------------|--------------|----------|
| **Строк кода** | 200+ | 60 | **70%** 📉 |
| **Файлов** | 3-4 | 2 | **50%** |
| **Время разработки** | 4 часа | 30 минут | **87.5%** ⚡ |
| **Вероятность багов** | Высокая | Минимальная | **~90%** 🛡️ |
| **Синхронизация** | Ручная | Авто | **100%** 🔄 |
| **Документация** | Отдельная | Spec = Docs | **∞%** 📚 |
| **Изменения API** | 2-3 часа | 5 секунд | **99.95%** 🚀 |

**⏱️ Время демо: 5 минут**

---

## <a name="demo-5"></a>Демо 5: Live Coding - E-commerce API 🛒

### Цель: Показать процесс разработки от нуля до API

#### Сценарий: Создать API для интернет-магазина за 15 минут

**Таймлайн:**

```
Минута 0-3:   Проектирование (OpenAPI spec)
Минута 3-4:   Генерация типов (UniStructGen)
Минута 4-10:  Handlers (бизнес-логика)
Минута 10-12: Setup & routing
Минута 12-15: Тестирование
```

#### Минута 0-3: Проектируем API

```yaml
# openapi.yaml
openapi: 3.0.0
info:
  title: E-commerce API
  version: 1.0.0

components:
  schemas:
    Product:
      type: object
      required: [id, name, price, stock]
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
          minLength: 3
          maxLength: 100
        description:
          type: string
          maxLength: 1000
        price:
          type: number
          format: double
          minimum: 0.01
        stock:
          type: integer
          minimum: 0
        category:
          $ref: '#/components/schemas/Category'

    Category:
      type: string
      enum: [electronics, clothing, books, food, toys]

    CreateProduct:
      type: object
      required: [name, price, stock, category]
      properties:
        name:
          type: string
          minLength: 3
          maxLength: 100
        description:
          type: string
          maxLength: 1000
        price:
          type: number
          minimum: 0.01
        stock:
          type: integer
          minimum: 0
        category:
          $ref: '#/components/schemas/Category'

    Order:
      type: object
      required: [id, items, total, status, created_at]
      properties:
        id:
          type: string
          format: uuid
        items:
          type: array
          items:
            $ref: '#/components/schemas/OrderItem'
        total:
          type: number
          format: double
        status:
          $ref: '#/components/schemas/OrderStatus'
        created_at:
          type: string
          format: date-time

    OrderItem:
      type: object
      required: [product_id, quantity, price]
      properties:
        product_id:
          type: string
          format: uuid
        quantity:
          type: integer
          minimum: 1
        price:
          type: number

    OrderStatus:
      type: string
      enum: [pending, processing, shipped, delivered, cancelled]
```

#### Минута 3-4: Генерируем типы

```rust
// src/models.rs
use unistructgen::openapi_to_rust;

openapi_to_rust! {
    file = "openapi.yaml"
}

// 🎉 Готово! 7 типов сгенерировано за 5 секунд!
```

#### Минута 4-10: Пишем handlers

```rust
// src/handlers.rs
use axum::{extract::{Path, State}, http::StatusCode, Json};
use uuid::Uuid;

use crate::models::*;
use crate::AppState;

// PRODUCTS

pub async fn create_product(
    State(state): State<AppState>,
    Json(create): Json<CreateProduct>,
) -> Result<Json<Product>, StatusCode> {
    let product = Product {
        id: Uuid::new_v4(),
        name: create.name,
        description: create.description,
        price: create.price,
        stock: create.stock,
        category: create.category,
    };

    state.products.lock().unwrap().push(product.clone());
    Ok(Json(product))
}

pub async fn list_products(
    State(state): State<AppState>,
) -> Json<Vec<Product>> {
    Json(state.products.lock().unwrap().clone())
}

pub async fn get_product(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
) -> Result<Json<Product>, StatusCode> {
    state.products
        .lock()
        .unwrap()
        .iter()
        .find(|p| p.id == id)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

// ORDERS

pub async fn create_order(
    State(state): State<AppState>,
    Json(items): Json<Vec<OrderItem>>,
) -> Result<Json<Order>, StatusCode> {
    // Вычисляем total
    let total: f64 = items.iter().map(|item| {
        item.price * item.quantity as f64
    }).sum();

    let order = Order {
        id: Uuid::new_v4(),
        items,
        total,
        status: OrderStatus::Pending,
        created_at: chrono::Utc::now(),
    };

    state.orders.lock().unwrap().push(order.clone());
    Ok(Json(order))
}

pub async fn list_orders(
    State(state): State<AppState>,
) -> Json<Vec<Order>> {
    Json(state.orders.lock().unwrap().clone())
}

pub async fn update_order_status(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
    Json(status): Json<OrderStatus>,
) -> Result<Json<Order>, StatusCode> {
    let mut orders = state.orders.lock().unwrap();

    orders.iter_mut()
        .find(|o| o.id == id)
        .map(|order| {
            order.status = status;
            Json(order.clone())
        })
        .ok_or(StatusCode::NOT_FOUND)
}
```

#### Минута 10-12: Setup и routing

```rust
// src/main.rs
use axum::{
    routing::{get, post, patch},
    Router,
};
use std::sync::{Arc, Mutex};

mod models;
mod handlers;

use models::{Product, Order};
use handlers::*;

#[derive(Clone)]
pub struct AppState {
    products: Arc<Mutex<Vec<Product>>>,
    orders: Arc<Mutex<Vec<Order>>>,
}

#[tokio::main]
async fn main() {
    let state = AppState {
        products: Arc::new(Mutex::new(Vec::new())),
        orders: Arc::new(Mutex::new(Vec::new())),
    };

    let app = Router::new()
        // Products
        .route("/products", get(list_products).post(create_product))
        .route("/products/:id", get(get_product))
        // Orders
        .route("/orders", get(list_orders).post(create_order))
        .route("/orders/:id/status", patch(update_order_status))
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();

    println!("🛒 E-commerce API running on http://localhost:3000");

    axum::serve(listener, app).await.unwrap();
}
```

#### Минута 12-15: Тестирование

```bash
# Создаём продукт
curl -X POST http://localhost:3000/products \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Gaming Laptop",
    "description": "High-performance laptop for gaming",
    "price": 1299.99,
    "stock": 10,
    "category": "electronics"
  }'

# Получаем все продукты
curl http://localhost:3000/products

# Создаём заказ
curl -X POST http://localhost:3000/orders \
  -H "Content-Type: application/json" \
  -d '[
    {
      "product_id": "550e8400-e29b-41d4-a716-446655440000",
      "quantity": 2,
      "price": 1299.99
    }
  ]'

# Обновляем статус заказа
curl -X PATCH http://localhost:3000/orders/{order_id}/status \
  -H "Content-Type: application/json" \
  -d '"shipped"'
```

### 🎉 Результат:

**За 15 минут мы создали:**

- ✅ Полноценный E-commerce API
- ✅ 7 типов с валидацией
- ✅ 6 endpoints (CRUD для Products и Orders)
- ✅ Production-ready код
- ✅ Type-safe на 100%

**Без UniStructGen это заняло бы 2-3 дня!**

**⏱️ Время демо: 15 минут**

---

## 🎬 Советы для проведения демо

### Подготовка:

1. **Заранее протестируйте** все примеры
2. **Подготовьте терминалы** с открытыми файлами
3. **Настройте размер шрифта** (audience должна видеть код)
4. **Держите под рукой** curl команды

### Во время демо:

1. **Начинайте с проблемы** - покажите боль ручного кода
2. **Живое кодирование** - пишите макросы на глазах audience
3. **Запускайте немедленно** - покажите, что это работает
4. **Сравнивайте** - до/после визуально впечатляет
5. **Отвечайте на вопросы** - но не уходите в детали

### Общие ошибки:

- ❌ Слишком быстро печатаете
- ❌ Забываете объяснять что делаете
- ❌ Слишком углубляетесь в детали
- ❌ Не показываете результат работы

### Успешное демо:

- ✅ Чёткая структура (проблема → решение → результат)
- ✅ Живой код (не презентация!)
- ✅ Впечатляющие метрики (99% меньше кода!)
- ✅ Интерактив (вопросы от audience)

---

## 📈 Чеклист для лекции

### Перед началом:

- [ ] Все примеры протестированы
- [ ] Терминалы настроены и готовы
- [ ] Презентация открыта
- [ ] Интернет работает (для live API примеров)
- [ ] Backup план если что-то сломается

### Во время:

- [ ] Начали с проблемы
- [ ] Показали простой пример (Hello World)
- [ ] Показали реальный пример (GitHub API)
- [ ] Показали full-stack пример (CRUD API)
- [ ] Сравнили до/после
- [ ] Ответили на вопросы

### После:

- [ ] Дали ссылки на ресурсы
- [ ] Призвали попробовать
- [ ] Собрали feedback

---

## 🎁 Бонусные материалы для audience

### Файлы для раздачи:

1. **Quick Start Guide** - как начать за 5 минут
2. **Cheat Sheet** - основные макросы и команды
3. **Example Projects** - готовые примеры для экспериментов
4. **Troubleshooting Guide** - решение частых проблем

### Онлайн ресурсы:

- 📚 GitHub репозиторий с примерами
- 📖 Полная документация
- 💬 Discord community
- 🎥 Video tutorials

---

**Удачи с лекцией! 🚀**

*Помните: лучшее демо - это то, где код работает с первого раза и audience говорит "Wow!"*