my-fullstack-app/
├── Cargo.toml              # ワークスペースのルート
├── Cargo.lock              # 依存関係のロックファイル
├── frontend/               # Leptosフロントエンド
│   ├── Cargo.toml
│   └── src/
├── backend/                # axumバックエンド
│   ├── Cargo.toml
│   └── src/
├── migrations/             # SQLxマイグレーション
├── docker-compose.yml
├── Makefile
└── terraform/              # インフラコード

backend/src/
├── main.rs                 # エントリーポイント
├── auth.rs                 # 認証ロジック（JWT生成・検証）
├── handlers/               # HTTPハンドラー
│   ├── mod.rs              # ← これが必要！
│   ├── auth.rs
│   └── users.rs
├── models/                 # データモデル
│   ├── mod.rs
│   ├── user.rs
│   └── error.rs
├── middlewares/            # ミドルウェア
│   ├── mod.rs
│   └── cors.rs
└── extractors/             # カスタムExtractor
    ├── mod.rs
    └── auth.rs

// backend/src/handlers/mod.rs
pub mod auth;   // handlers/auth.rs を公開
pub mod users;  // handlers/users.rs を公開

// 共通で使う関数やルーターをここで定義することも多い
use axum::Router;
use std::sync::Arc;
use crate::AppState;

pub fn api_router() -> Router<Arc<AppState>> {
    Router::new()
        .nest("/auth", auth::router())
        .nest("/users", users::router())
}

// backend/src/models/mod.rs
mod user;   // models/user.rs（非公開、このモジュール内でのみ使用）
mod error;  // models/error.rs

// 外部に公開するものだけ re-export
pub use user::{User, UserResponse, CreateUserRequest};
pub use error::AppError;

frontend/src/
├── main.rs
├── app.rs                  # ルートコンポーネント
├── components/             # UIコンポーネント
│   ├── mod.rs
│   ├── home_page.rs
│   ├── login_page.rs
│   └── dashboard_page.rs
├── api/                    # APIクライアント
│   ├── mod.rs
│   ├── client.rs
│   ├── auth.rs
│   └── users.rs
└── context/                # Context（状態管理）
    ├── mod.rs
    └── auth.rs

// frontend/src/components/mod.rs
mod home_page;
mod login_page;
mod dashboard_page;
mod not_found_page;

pub use home_page::HomePage;
pub use login_page::LoginPage;
pub use dashboard_page::DashboardPage;
pub use not_found_page::NotFoundPage;

// frontend/src/api/mod.rs
pub mod client;  // client を公開（他のモジュールから api::client::get などでアクセス）
pub mod auth;
pub mod users;

// frontend/src/context/mod.rs
mod auth;

pub use auth::{AuthContext, AuthProvider, use_auth};

[workspace]
resolver = "3"
members = ["frontend", "backend"]

[workspace.dependencies]
# 共通で使う依存関係
serde = "1.0"
serde_json = "1.0"
thiserror = "2.0"
chrono = "0.4"
uuid = "1.18"

# フロントエンド用
leptos = "0.8"
leptos_router = "0.8"
wasm-bindgen = "0.2"
web-sys = "0.3"
reqwasm = "0.5"  # HTTP クライアント（Leptos では gloo-net より安定）

# バックエンド用
axum = "0.8"
tokio = "1.48"
sqlx = "0.8"
jsonwebtoken = "10.1"
bcrypt = "0.18"
tower-http = "0.6"
tracing = "0.1"
tracing-subscriber = "0.3"

# 例: reqwest をフロントとバックで別々に使う場合
# バックエンドでは TLS 機能が必要、フロントエンドでは不要
# resolver = "3" なら適切に分離してくれる

# backend/Cargo.toml
[package]
name = "backend"
version = "0.1.0"
edition = "2024"

[dependencies]
serde = { workspace = true }
serde_json = { workspace = true }
axum = { workspace = true }
tokio = { workspace = true, features = ["full"] }
sqlx = { workspace = true, features = ["runtime-tokio", "postgres"] }

# どうしても揃わないときの最終手段
[patch.crates-io]
some-crate = { version = "1.0.210" }

# docker-compose.yml
services:
  postgres:
    image: postgres:17-alpine
    container_name: myapp-postgres
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    ports:
      - "127.0.0.1:5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 10s
      timeout: 5s
      retries: 5

  backend:
    build:
      context: .
      dockerfile: backend/Dockerfile.dev
    container_name: myapp-backend
    environment:
      DATABASE_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
      ACCESS_TOKEN_SECRET: ${ACCESS_TOKEN_SECRET}
      REFRESH_TOKEN_SECRET: ${REFRESH_TOKEN_SECRET}
      RUST_LOG: debug
    ports:
      - "${BACKEND_PORT:-3000}:3000"
    volumes:
      - .:/app
      - backend_cache:/app/backend/target
      - cargo_cache_backend:/app/.cargo
    depends_on:
      postgres:
        condition: service_healthy

  frontend:
    build:
      context: .
      dockerfile: frontend/Dockerfile.dev
    container_name: myapp-frontend
    environment:
      API_BASE_URL: http://localhost:${BACKEND_PORT:-3000}
    ports:
      - "${FRONTEND_PORT:-8080}:8080"
    volumes:
      - .:/app
      - frontend_cache:/app/frontend/target
      - cargo_cache_frontend:/app/.cargo

volumes:
  postgres_data:
  backend_cache:
  frontend_cache:
  cargo_cache_backend:
  cargo_cache_frontend:

# backend/Dockerfile.dev
FROM rust:1.92-slim-bookworm

WORKDIR /app

# 必要なツールをインストール
RUN apt-get update && apt-get install -y \
    pkg-config \
    libssl-dev \
    && rm -rf /var/lib/apt/lists/*

# cargo-watch をインストール（ホットリロード用）
RUN cargo install cargo-watch

# 開発用コマンド
CMD ["cargo", "watch", "-x", "run -p backend", "-w", "backend/src"]

# frontend/Dockerfile.dev
FROM rust:1.92-slim-bookworm

WORKDIR /app

# WASM ターゲットを追加
RUN rustup target add wasm32-unknown-unknown

# trunk をインストール
RUN cargo install trunk

# 開発用コマンド
CMD ["trunk", "serve", "--address", "0.0.0.0", "--port", "8080", "-w", "frontend/src"]

cargo watch -x "run -p backend" -w backend/src

trunk serve --address 0.0.0.0 --port 8080

.PHONY: dev down logs clean fmt lint migrate-add migrate-run

# ==========================================
# 開発環境
# ==========================================

# 開発環境を起動
dev:
	docker compose --env-file .env.development up --build

# バックグラウンドで起動
dev-bg:
	docker compose --env-file .env.development up -d --build

# 停止
down:
	docker compose down

# ログ表示
logs:
	docker compose logs -f

# バックエンドのログのみ
logs-backend:
	docker compose logs -f backend

# クリーンアップ（ボリュームも削除）
clean:
	docker compose down -v
	docker system prune -f

# ==========================================
# コード品質
# ==========================================

# コード整形
fmt:
	cargo fmt
	leptosfmt ./frontend/src

# Lint チェック
lint:
	cargo clippy --package backend -- -W warnings
	cargo clippy --package frontend --target wasm32-unknown-unknown -- -W warnings

# ==========================================
# データベース
# ==========================================

# マイグレーション作成
migrate-add:
	@read -p "Migration name: " name; \
	sqlx migrate add -r $$name

# マイグレーション実行
migrate-run:
	sqlx migrate run --database-url ${DATABASE_URL}

# マイグレーション状態確認
migrate-info:
	sqlx migrate info --database-url ${DATABASE_URL}

# ==========================================
# セットアップ
# ==========================================

# 初期セットアップ
setup:
	@echo "🔧 環境ファイルをセットアップ中..."
	@if [ ! -f .env.development ]; then \
		cp .env.example .env.development; \
		echo "✅ .env.development を作成しました"; \
	fi
	@echo "⚠️  .env.development を編集してください"

# WASM ターゲット追加
setup-wasm:
	rustup target add wasm32-unknown-unknown

# ヘルプ
help:
	@echo "使用可能なコマンド:"
	@echo "  make dev          - 開発環境を起動"
	@echo "  make down         - 停止"
	@echo "  make logs         - ログ表示"
	@echo "  make clean        - クリーンアップ"
	@echo "  make fmt          - コード整形"
	@echo "  make lint         - Lint チェック"
	@echo "  make migrate-add  - マイグレーション作成"
	@echo "  make migrate-run  - マイグレーション実行"
	@echo "  make setup        - 初期セットアップ"

# .env.example（テンプレート）
POSTGRES_USER=myapp
POSTGRES_PASSWORD=your_password_here
POSTGRES_DB=myapp_development

DATABASE_URL=postgres://myapp:your_password_here@localhost:5432/myapp_development

BACKEND_PORT=3000
FRONTEND_PORT=8080

# JWT シークレット（本番では 64 文字以上のランダム文字列を使用）
ACCESS_TOKEN_SECRET=your_access_token_secret_here_at_least_64_characters_long_random
REFRESH_TOKEN_SECRET=your_refresh_token_secret_here_at_least_64_characters_long_random

# .gitignore
.env.development
.env.staging
.env.production

# backend/Cargo.toml
[package]
name = "backend"
version = "0.1.0"
edition = "2024"

[dependencies]
# Web フレームワーク
axum = { workspace = true }
axum-extra = { workspace = true, features = ["cookie"] }
tokio = { workspace = true, features = ["full"] }
tower = { workspace = true }
tower-http = { workspace = true, features = ["cors", "trace"] }

# データベース
sqlx = { workspace = true, features = ["runtime-tokio", "postgres", "uuid", "chrono"] }

# 認証
jsonwebtoken = { workspace = true, features = ["rust_crypto"] }
bcrypt = { workspace = true }
sha2 = { workspace = true }

# シリアライゼーション
serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }

# ユーティリティ
chrono = { workspace = true, features = ["serde"] }
uuid = { workspace = true, features = ["v4", "serde"] }
thiserror = { workspace = true }
anyhow = { workspace = true }

# ロギング
tracing = { workspace = true }
tracing-subscriber = { workspace = true, features = ["env-filter"] }

# 環境変数
dotenvy = { workspace = true }

// backend/src/main.rs
use std::net::SocketAddr;
use std::sync::Arc;

use axum::{Router, routing::get};
use sqlx::postgres::PgPoolOptions;
use tower_http::cors::CorsLayer;
use tower_http::trace::TraceLayer;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

mod handlers;
mod models;
mod auth;
mod middlewares;

// アプリケーション全体で共有する状態
#[derive(Clone)]
pub struct AppState {
    pub db: sqlx::PgPool,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 環境変数を読み込み
    dotenvy::dotenv().ok();

    // ロギングの初期化
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::try_from_default_env()
            .unwrap_or_else(|_| "backend=debug,tower_http=debug".into()))
        .with(tracing_subscriber::fmt::layer())
        .init();

    // データベース接続プールを作成
    let database_url = std::env::var("DATABASE_URL")
        .expect("DATABASE_URL must be set");

    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

    // マイグレーションを実行
    sqlx::migrate!("../migrations")
        .run(&pool)
        .await?;

    tracing::info!("✅ Database connected and migrations applied");

    // JWT シークレットの検証（起動時に弱いシークレットを検出）
    auth::validate_jwt_secrets()?;

    // アプリケーション状態を作成
    let state = Arc::new(AppState { db: pool });

    // ルーターを構築
    let app = Router::new()
        // ヘルスチェック
        .route("/health", get(|| async { "OK" }))
        // API ルート
        .nest("/api", handlers::api_router())
        // 状態を注入
        .with_state(state)
        // ミドルウェア
        .layer(middlewares::cors::cors_layer())
        .layer(TraceLayer::new_for_http());

    // サーバーを起動
    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    tracing::info!("🚀 Server listening on {}", addr);

    let listener = tokio::net::TcpListener::bind(addr).await?;
    axum::serve(listener, app).await?;

    Ok(())
}

#[derive(Clone)]
pub struct AppState {
    pub db: sqlx::PgPool,
}

let app = Router::new()
    .route("/health", get(|| async { "OK" }))
    .nest("/api", handlers::api_router())
    .with_state(state)
    .layer(middlewares::cors::cors_layer())
    .layer(TraceLayer::new_for_http());

// backend/src/handlers/mod.rs
use axum::Router;
use std::sync::Arc;

use crate::AppState;

mod auth;
mod users;

pub fn api_router() -> Router<Arc<AppState>> {
    Router::new()
        .nest("/auth", auth::router())
        .nest("/users", users::router())
}

// backend/src/handlers/auth.rs
use axum::{Router, routing::post, Json, extract::State};
use std::sync::Arc;

use crate::AppState;
use crate::models::{LoginRequest, LoginResponse, RegisterRequest};

pub fn router() -> Router<Arc<AppState>> {
    Router::new()
        .route("/login", post(login))
        .route("/register", post(register))
        .route("/refresh", post(refresh_token))
        .route("/logout", post(logout))
}

async fn login(
    State(state): State<Arc<AppState>>,
    Json(payload): Json<LoginRequest>,
) -> Result<Json<LoginResponse>, AppError> {
    // ログイン処理...
    // 具体的な実装（パスワード検証、JWT生成、Cookie設定）は
    // 後述の「認証実装」セクションおよび過去記事を参照
    todo!()
}

async fn register(
    State(state): State<Arc<AppState>>,
    Json(payload): Json<RegisterRequest>,
) -> Result<Json<LoginResponse>, AppError> {
    // 登録処理...
    // パスワードハッシュ化は bcrypt::hash() を使用
    // 具体的な実装は後述の「認証実装」セクションを参照
    todo!()
}

async fn login(
    State(state): State<Arc<AppState>>,  // アプリケーション状態
    Json(payload): Json<LoginRequest>,    // JSON ボディ
) -> Result<Json<LoginResponse>, AppError> {
    // ...
}

// ✅ 正しい順序
async fn handler(
    State(state): State<Arc<AppState>>,
    Path(id): Path<Uuid>,
    Json(body): Json<CreateRequest>,
) -> Result<Json<Response>, AppError> { ... }

// ❌ コンパイルエラー（Json が先にあると Path が取れない）
async fn handler(
    Json(body): Json<CreateRequest>,
    Path(id): Path<Uuid>,
) -> Result<Json<Response>, AppError> { ... }

// backend/src/models/error.rs
use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde_json::json;

#[derive(Debug)]
pub enum AppError {
    // 認証エラー
    Unauthorized,
    InvalidCredentials,
    TokenExpired,

    // バリデーションエラー
    ValidationError(String),

    // リソースエラー
    NotFound,
    Conflict(String),

    // 内部エラー
    InternalError(anyhow::Error),
    DatabaseError(sqlx::Error),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, message) = match self {
            AppError::Unauthorized => {
                (StatusCode::UNAUTHORIZED, "認証が必要です")
            }
            AppError::InvalidCredentials => {
                (StatusCode::UNAUTHORIZED, "メールアドレスまたはパスワードが正しくありません")
            }
            AppError::TokenExpired => {
                (StatusCode::UNAUTHORIZED, "トークンの有効期限が切れています")
            }
            AppError::ValidationError(msg) => {
                (StatusCode::BAD_REQUEST, msg.as_str())
            }
            AppError::NotFound => {
                (StatusCode::NOT_FOUND, "リソースが見つかりません")
            }
            AppError::Conflict(msg) => {
                (StatusCode::CONFLICT, msg.as_str())
            }
            AppError::InternalError(e) => {
                tracing::error!("Internal error: {:?}", e);
                (StatusCode::INTERNAL_SERVER_ERROR, "内部エラーが発生しました")
            }
            AppError::DatabaseError(e) => {
                tracing::error!("Database error: {:?}", e);
                (StatusCode::INTERNAL_SERVER_ERROR, "データベースエラーが発生しました")
            }
        };

        let body = Json(json!({
            "error": message,
        }));

        (status, body).into_response()
    }
}

// sqlx::Error から AppError への変換
impl From<sqlx::Error> for AppError {
    fn from(e: sqlx::Error) -> Self {
        AppError::DatabaseError(e)
    }
}

// anyhow::Error から AppError への変換
impl From<anyhow::Error> for AppError {
    fn from(e: anyhow::Error) -> Self {
        AppError::InternalError(e)
    }
}

async fn get_user(
    State(state): State<Arc<AppState>>,
    Path(id): Path<Uuid>,
) -> Result<Json<User>, AppError> {
    let user = sqlx::query_as::<_, User>("SELECT * FROM users WHERE id = $1")
        .bind(id)
        .fetch_optional(&state.db)
        .await?  // sqlx::Error が自動的に AppError に変換される
        .ok_or(AppError::NotFound)?;

    Ok(Json(user))
}

// backend/src/middlewares/cors.rs
use axum::http::{header, Method};
use tower_http::cors::{Any, CorsLayer};

pub fn cors_layer() -> CorsLayer {
    CorsLayer::new()
        .allow_origin([
            "http://localhost:8080".parse().unwrap(),
            "https://myapp.example.com".parse().unwrap(),
        ])
        .allow_methods([
            Method::GET,
            Method::POST,
            Method::PUT,
            Method::DELETE,
            Method::PATCH,
        ])
        .allow_headers([
            header::CONTENT_TYPE,
            header::AUTHORIZATION,
            header::ACCEPT,
        ])
        .allow_credentials(true)
}

// リクエスト用（デシリアライズが必要）
#[derive(Debug, Deserialize)]
pub struct CreateUserRequest {
    pub email: String,
    pub password: String,
    pub name: String,
}

// レスポンス用（シリアライズが必要）
#[derive(Debug, Serialize)]
pub struct UserResponse {
    pub id: Uuid,
    pub email: String,
    pub name: String,
    pub created_at: DateTime<Utc>,
}

// データベースから取得用（SQLx の FromRow）
#[derive(Debug, sqlx::FromRow)]
pub struct User {
    pub id: Uuid,
    pub email: String,
    pub password_hash: String,
    pub name: String,
    pub created_at: DateTime<Utc>,
}

// 状態共有用（Clone が必要）
#[derive(Clone)]
pub struct AppState {
    pub db: sqlx::PgPool,
}

cargo install sqlx-cli --no-default-features --features postgres

# .env
DATABASE_URL=postgres://myapp:password@localhost:5432/myapp_development

export DATABASE_URL="postgres://myapp:password@localhost:5432/myapp_development"

# クエリ情報を JSON ファイルに保存
cargo sqlx prepare --workspace

# これで sqlx-data.json が生成される
# このファイルをリポジトリにコミットしておく

# マイグレーションディレクトリを作成
sqlx migrate add -r create_users_table

migrations/
├── 20260119000000_create_users_table.up.sql
└── 20260119000000_create_users_table.down.sql

-- migrations/20260119000000_create_users_table.up.sql

-- UUID 拡張を有効化
CREATE EXTENSION IF NOT EXISTS "pgcrypto";

-- ユーザーテーブル
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email TEXT UNIQUE NOT NULL,
    password_hash TEXT NOT NULL,
    name TEXT NOT NULL,
    failed_login_attempts INTEGER DEFAULT 0,
    locked_until TIMESTAMP WITH TIME ZONE,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL
);

-- リフレッシュトークンテーブル
CREATE TABLE refresh_tokens (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    token_hash VARCHAR(255) NOT NULL,
    expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
    revoked BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL
);

-- インデックス
CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_refresh_tokens_user_id ON refresh_tokens(user_id);
CREATE INDEX idx_refresh_tokens_token_hash ON refresh_tokens(token_hash);

-- updated_at を自動更新するトリガー
CREATE OR REPLACE FUNCTION update_updated_at()
RETURNS TRIGGER AS $$
BEGIN
    NEW.updated_at = CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER users_updated_at
    BEFORE UPDATE ON users
    FOR EACH ROW
    EXECUTE FUNCTION update_updated_at();

-- migrations/20260119000000_create_users_table.down.sql

DROP TRIGGER IF EXISTS users_updated_at ON users;
DROP FUNCTION IF EXISTS update_updated_at();
DROP TABLE IF EXISTS refresh_tokens;
DROP TABLE IF EXISTS users;

# マイグレーションを実行
sqlx migrate run

# 状態を確認
sqlx migrate info

# ロールバック（1つ前に戻す）
sqlx migrate revert

// main.rs 内
sqlx::migrate!("../migrations")
    .run(&pool)
    .await?;

pub async fn create_user(
    pool: &PgPool,
    email: &str,
    password_hash: &str,
    name: &str,
) -> Result<User, sqlx::Error> {
    let user = sqlx::query_as::<_, User>(
        r#"
        INSERT INTO users (email, password_hash, name)
        VALUES ($1, $2, $3)
        RETURNING id, email, password_hash, name, failed_login_attempts,
                  locked_until, created_at, updated_at
        "#,
    )
    .bind(email)
    .bind(password_hash)
    .bind(name)
    .fetch_one(pool)
    .await?;

    Ok(user)
}

// 単一取得
pub async fn find_user_by_id(
    pool: &PgPool,
    id: Uuid,
) -> Result<Option<User>, sqlx::Error> {
    let user = sqlx::query_as::<_, User>(
        "SELECT * FROM users WHERE id = $1"
    )
    .bind(id)
    .fetch_optional(pool)
    .await?;

    Ok(user)
}

// メールアドレスで検索
pub async fn find_user_by_email(
    pool: &PgPool,
    email: &str,
) -> Result<Option<User>, sqlx::Error> {
    let user = sqlx::query_as::<_, User>(
        "SELECT * FROM users WHERE email = $1"
    )
    .bind(email)
    .fetch_optional(pool)
    .await?;

    Ok(user)
}

// 一覧取得
pub async fn list_users(
    pool: &PgPool,
    limit: i64,
    offset: i64,
) -> Result<Vec<User>, sqlx::Error> {
    let users = sqlx::query_as::<_, User>(
        "SELECT * FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2"
    )
    .bind(limit)
    .bind(offset)
    .fetch_all(pool)
    .await?;

    Ok(users)
}

pub async fn update_user_name(
    pool: &PgPool,
    id: Uuid,
    name: &str,
) -> Result<User, sqlx::Error> {
    let user = sqlx::query_as::<_, User>(
        r#"
        UPDATE users
        SET name = $1
        WHERE id = $2
        RETURNING *
        "#,
    )
    .bind(name)
    .bind(id)
    .fetch_one(pool)
    .await?;

    Ok(user)
}

pub async fn delete_user(
    pool: &PgPool,
    id: Uuid,
) -> Result<(), sqlx::Error> {
    sqlx::query("DELETE FROM users WHERE id = $1")
        .bind(id)
        .execute(pool)
        .await?;

    Ok(())
}

pub async fn create_user_with_token(
    pool: &PgPool,
    email: &str,
    password_hash: &str,
    name: &str,
    refresh_token_hash: &str,
    expires_at: DateTime<Utc>,
) -> Result<(User, Uuid), sqlx::Error> {
    // トランザクションを開始
    let mut tx = pool.begin().await?;

    // ユーザーを作成
    let user = sqlx::query_as::<_, User>(
        r#"
        INSERT INTO users (email, password_hash, name)
        VALUES ($1, $2, $3)
        RETURNING *
        "#,
    )
    .bind(email)
    .bind(password_hash)
    .bind(name)
    .fetch_one(&mut *tx)
    .await?;

    // リフレッシュトークンを作成
    let token_id: Uuid = sqlx::query_scalar(
        r#"
        INSERT INTO refresh_tokens (user_id, token_hash, expires_at)
        VALUES ($1, $2, $3)
        RETURNING id
        "#,
    )
    .bind(user.id)
    .bind(refresh_token_hash)
    .bind(expires_at)
    .fetch_one(&mut *tx)
    .await?;

    // コミット
    tx.commit().await?;

    Ok((user, token_id))
}

// データベースのカラムに対応した構造体
#[derive(Debug, sqlx::FromRow)]
pub struct User {
    pub id: Uuid,
    pub email: String,
    pub password_hash: String,
    pub name: String,
    pub failed_login_attempts: i32,
    pub locked_until: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

// API レスポンス用（パスワードハッシュを含まない）
#[derive(Debug, Serialize)]
pub struct UserResponse {
    pub id: Uuid,
    pub email: String,
    pub name: String,
    pub created_at: DateTime<Utc>,
}

impl From<User> for UserResponse {
    fn from(user: User) -> Self {
        Self {
            id: user.id,
            email: user.email,
            name: user.name,
            created_at: user.created_at,
        }
    }
}

// マクロ版（コンパイル時検証あり）
let user = sqlx::query_as!(
    User,
    "SELECT * FROM users WHERE id = $1",
    id
)
.fetch_optional(pool)
.await?;

// backend/src/models/auth.rs
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Claims {
    pub sub: String,        // ユーザーID
    pub email: String,
    pub exp: i64,           // 有効期限
    pub iat: i64,           // 発行時刻
    pub token_type: String, // "access" or "refresh"
    pub aud: String,        // オーディエンス
}

// 認証済みユーザー（Extractor から取得）
#[derive(Debug, Clone)]
pub struct AuthUser {
    pub id: Uuid,
    pub email: String,
}

// backend/src/extractors/auth.rs
use axum::{
    async_trait,
    extract::FromRequestParts,
    http::{request::Parts, StatusCode},
    response::{IntoResponse, Response},
    Json,
};
use axum_extra::extract::CookieJar;
use serde_json::json;
use uuid::Uuid;

use crate::auth::verify_access_token;
use crate::models::AuthUser;

// 認証エラー
pub struct AuthError {
    message: String,
    status: StatusCode,
}

impl IntoResponse for AuthError {
    fn into_response(self) -> Response {
        let body = Json(json!({
            "error": self.message,
        }));
        (self.status, body).into_response()
    }
}

// AuthUser の Extractor 実装
#[async_trait]
impl<S> FromRequestParts<S> for AuthUser
where
    S: Send + Sync,
{
    type Rejection = AuthError;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        // Cookie から Access Token を取得
        let jar = CookieJar::from_request_parts(parts, state)
            .await
            .map_err(|_| AuthError {
                message: "Cookie の取得に失敗しました".to_string(),
                status: StatusCode::INTERNAL_SERVER_ERROR,
            })?;

        let token = jar
            .get("access_token")
            .map(|c| c.value().to_string())
            .ok_or_else(|| AuthError {
                message: "認証が必要です".to_string(),
                status: StatusCode::UNAUTHORIZED,
            })?;

        // トークンを検証
        let claims = verify_access_token(&token).map_err(|e| {
            tracing::warn!("Token verification failed: {:?}", e);
            AuthError {
                message: "トークンが無効です".to_string(),
                status: StatusCode::UNAUTHORIZED,
            }
        })?;

        // ユーザーID をパース
        let user_id = Uuid::parse_str(&claims.sub).map_err(|_| AuthError {
            message: "無効なユーザーIDです".to_string(),
            status: StatusCode::UNAUTHORIZED,
        })?;

        Ok(AuthUser {
            id: user_id,
            email: claims.email,
        })
    }
}

// 認証が必要なエンドポイント
async fn get_me(auth_user: AuthUser) -> Json<UserResponse> {
    // auth_user には認証済みユーザーの情報が入っている
    Json(UserResponse {
        id: auth_user.id,
        email: auth_user.email,
        // ...
    })
}

// 認証が不要なエンドポイント（AuthUser を引数に含めない）
async fn health() -> &'static str {
    "OK"
}

async fn get_article(
    auth_user: Option<AuthUser>,
    Path(id): Path<Uuid>,
) -> Json<ArticleResponse> {
    // ログインしていれば「いいね済み」フラグを含める
    let is_liked = if let Some(user) = &auth_user {
        check_user_liked(user.id, id).await
    } else {
        false
    };

    // ...
}

// 管理者ユーザー
#[derive(Debug, Clone)]
pub struct AdminUser {
    pub id: Uuid,
    pub email: String,
}

#[async_trait]
impl<S> FromRequestParts<S> for AdminUser
where
    S: Send + Sync,
{
    type Rejection = AuthError;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        // まず AuthUser として認証
        let auth_user = AuthUser::from_request_parts(parts, state).await?;

        // 管理者かどうかをチェック（ここでは簡略化）
        // 実際には DB から権限を確認する
        if !is_admin(&auth_user.email) {
            return Err(AuthError {
                message: "管理者権限が必要です".to_string(),
                status: StatusCode::FORBIDDEN,
            });
        }

        Ok(AdminUser {
            id: auth_user.id,
            email: auth_user.email,
        })
    }
}

fn is_admin(email: &str) -> bool {
    // 実際には DB から確認する
    email.ends_with("@admin.example.com")
}

// 管理者専用エンドポイント
async fn admin_dashboard(admin: AdminUser) -> Json<DashboardResponse> {
    // 管理者のみアクセス可能
    // ...
}

// 依存関係の例
// AdminUser → AuthUser → CookieJar

// ハンドラーで使うとき
async fn handler(admin: AdminUser) -> Json<Response> {
    // AdminUser の Extractor が呼ばれる
    // → 内部で AuthUser の Extractor が呼ばれる
    // → 内部で CookieJar の Extractor が呼ばれる
    // ...
}

# frontend/Cargo.toml
[package]
name = "frontend"
version = "0.1.0"
edition = "2024"

[dependencies]
# Leptos コア
leptos = { workspace = true, features = ["csr"] }
leptos_router = { workspace = true, features = ["csr"] }

# HTTP クライアント
reqwasm = { workspace = true }

# シリアライゼーション
serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }

# WASM
wasm-bindgen = { workspace = true }
wasm-bindgen-futures = { workspace = true }
web-sys = { workspace = true, features = ["Window", "Document", "Storage"] }

# ユーティリティ
chrono = { workspace = true, features = ["serde", "wasmbind"] }
uuid = { workspace = true, features = ["v4", "serde"] }
thiserror = { workspace = true }

# ロギング
log = { workspace = true }
console_log = { workspace = true }
console_error_panic_hook = { workspace = true }

# frontend/trunk.toml
[build]
target = "index.html"
dist = "dist"

[watch]
watch = ["src", "index.html", "style.css"]
ignore = []

[serve]
address = "0.0.0.0"
port = 8080

<!-- frontend/index.html -->
<!DOCTYPE html>
<html lang="ja">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My App</title>
    <link data-trunk rel="css" href="style.css">
</head>
<body>
    <link data-trunk rel="rust" data-wasm-opt="z">
</body>
</html>

// frontend/src/main.rs
use leptos::prelude::*;

mod app;
mod components;
mod api;
mod context;

fn main() {
    // パニック時のスタックトレースをコンソールに出力
    console_error_panic_hook::set_once();

    // ロギングの初期化
    console_log::init_with_level(log::Level::Debug).unwrap();

    // アプリケーションをマウント
    leptos::mount::mount_to_body(app::App);
}

// frontend/src/app.rs
use leptos::prelude::*;
use leptos_router::components::{Router, Routes, Route};
use leptos_router::path;

use crate::components::{HomePage, LoginPage, DashboardPage, NotFoundPage};
use crate::context::AuthProvider;

#[component]
pub fn App() -> impl IntoView {
    view! {
        <AuthProvider>
            <Router>
                <main class="container">
                    <Routes fallback=|| view! { <NotFoundPage /> }>
                        <Route path=path!("/") view=HomePage />
                        <Route path=path!("/login") view=LoginPage />
                        <Route path=path!("/dashboard") view=DashboardPage />
                    </Routes>
                </main>
            </Router>
        </AuthProvider>
    }
}

#[component]
fn Counter() -> impl IntoView {
    // Signal を作成（初期値は 0）
    let count = RwSignal::new(0);

    view! {
        <div>
            <p>"Count: " {move || count.get()}</p>
            <button on:click=move |_| count.set(count.get() + 1)>
                "Increment"
            </button>
        </div>
    }
}

// Memo の例：count が変わったときだけ再計算
let count = RwSignal::new(0);
let doubled = Memo::new(move |_| count.get() * 2);

view! {
    <p>"Count: " {move || count.get()}</p>
    <p>"Doubled: " {move || doubled.get()}</p>
}

// frontend/src/components/login_page.rs
use leptos::prelude::*;
use leptos_router::hooks::use_navigate;

use crate::api::auth::login;
use crate::context::use_auth;

#[component]
pub fn LoginPage() -> impl IntoView {
    let auth = use_auth();
    let navigate = use_navigate();

    // フォームの状態
    let email = RwSignal::new(String::new());
    let password = RwSignal::new(String::new());
    let error = RwSignal::new(None::<String>);
    let loading = RwSignal::new(false);

    // ログイン処理
    let on_submit = move |ev: web_sys::SubmitEvent| {
        ev.prevent_default();

        // ローディング状態に
        loading.set(true);
        error.set(None);

        // 値を取得
        let email_value = email.get();
        let password_value = password.get();

        // 非同期でログイン API を呼び出し
        spawn_local(async move {
            match login(&email_value, &password_value).await {
                Ok(user) => {
                    // 認証状態を更新
                    auth.login(user);
                    // ダッシュボードへリダイレクト
                    navigate("/dashboard", Default::default());
                }
                Err(e) => {
                    error.set(Some(e.to_string()));
                }
            }
            loading.set(false);
        });
    };

    view! {
        <div class="login-page">
            <h1>"ログイン"</h1>

            // エラーメッセージ
            {move || error.get().map(|e| view! {
                <div class="error">{e}</div>
            })}

            <form on:submit=on_submit>
                <div class="form-group">
                    <label for="email">"メールアドレス"</label>
                    <input
                        type="email"
                        id="email"
                        prop:value=move || email.get()
                        on:input=move |ev| email.set(event_target_value(&ev))
                        required
                    />
                </div>

                <div class="form-group">
                    <label for="password">"パスワード"</label>
                    <input
                        type="password"
                        id="password"
                        prop:value=move || password.get()
                        on:input=move |ev| password.set(event_target_value(&ev))
                        required
                    />
                </div>

                <button type="submit" disabled=move || loading.get()>
                    {move || if loading.get() { "ログイン中..." } else { "ログイン" }}
                </button>
            </form>
        </div>
    }
}

<input
    prop:value=move || email.get()
    on:input=move |ev| email.set(event_target_value(&ev))
/>

spawn_local(async move {
    match login(&email_value, &password_value).await {
        // ...
    }
});

// frontend/src/context/auth.rs
use leptos::prelude::*;

#[derive(Clone, Debug)]
pub struct User {
    pub id: String,
    pub email: String,
    pub name: String,
}

#[derive(Clone)]
pub struct AuthContext {
    pub user: RwSignal<Option<User>>,
}

impl AuthContext {
    pub fn new() -> Self {
        Self {
            user: RwSignal::new(None),
        }
    }

    pub fn login(&self, user: User) {
        self.user.set(Some(user));
    }

    pub fn logout(&self) {
        self.user.set(None);
    }

    pub fn is_authenticated(&self) -> bool {
        self.user.get().is_some()
    }
}

// Context を提供するコンポーネント
#[component]
pub fn AuthProvider(children: Children) -> impl IntoView {
    let auth = AuthContext::new();
    provide_context(auth);

    children()
}

// Context を使用するフック
pub fn use_auth() -> AuthContext {
    expect_context::<AuthContext>()
}

// ログイン状態に応じて表示を切り替え
#[component]
fn Header() -> impl IntoView {
    let auth = use_auth();

    view! {
        <header>
            {move || {
                if auth.is_authenticated() {
                    view! {
                        <span>"Welcome, " {auth.user.get().map(|u| u.name)}</span>
                        <button on:click=move |_| auth.logout()>"Logout"</button>
                    }.into_any()
                } else {
                    view! {
                        <a href="/login">"Login"</a>
                    }.into_any()
                }
            }}
        </header>
    }
}

// ❌ これはコンパイルエラー
let name = String::from("Alice");
view! {
    <p>{name}</p>  // name がムーブされる
    <p>{name}</p>  // 2回目で所有権エラー
}

let name = String::from("Alice");
view! {
    <p>{name.clone()}</p>
    <p>{name}</p>  // 最後は clone 不要
}

let name = RwSignal::new(String::from("Alice"));
view! {
    <p>{move || name.get()}</p>
    <p>{move || name.get()}</p>  // Signal は何度でも get できる
}

let config = StoredValue::new(Config { ... });
view! {
    <p>{config.get_value().name}</p>
    <p>{config.get_value().description}</p>
}

// frontend/src/api/client.rs
use reqwasm::http::Request;
use serde::{de::DeserializeOwned, Serialize};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum ApiError {
    #[error("Network error: {0}")]
    NetworkError(String),

    #[error("API error: {0}")]
    ApiError(String),

    #[error("Parse error: {0}")]
    ParseError(String),
}

fn api_base_url() -> String {
    // 環境変数またはデフォルト値
    option_env!("API_BASE_URL")
        .unwrap_or("http://localhost:3000")
        .to_string()
}

pub async fn get<T: DeserializeOwned>(path: &str) -> Result<T, ApiError> {
    let url = format!("{}/api{}", api_base_url(), path);

    let response = Request::get(&url)
        .credentials(reqwasm::http::RequestCredentials::Include)  // Cookie を送信
        .send()
        .await
        .map_err(|e| ApiError::NetworkError(e.to_string()))?;

    if !response.ok() {
        let error_text = response.text().await.unwrap_or_default();
        return Err(ApiError::ApiError(error_text));
    }

    response
        .json()
        .await
        .map_err(|e| ApiError::ParseError(e.to_string()))
}

pub async fn post<T: DeserializeOwned, B: Serialize>(
    path: &str,
    body: &B,
) -> Result<T, ApiError> {
    let url = format!("{}/api{}", api_base_url(), path);

    let json_body = serde_json::to_string(body)
        .map_err(|e| ApiError::ParseError(e.to_string()))?;

    let response = Request::post(&url)
        .credentials(reqwasm::http::RequestCredentials::Include)
        .header("Content-Type", "application/json")
        .body(json_body)
        .send()
        .await
        .map_err(|e| ApiError::NetworkError(e.to_string()))?;

    if !response.ok() {
        let error_text = response.text().await.unwrap_or_default();
        return Err(ApiError::ApiError(error_text));
    }

    response
        .json()
        .await
        .map_err(|e| ApiError::ParseError(e.to_string()))
}

// frontend/src/api/auth.rs
use serde::{Deserialize, Serialize};

use super::client::{post, ApiError};

#[derive(Debug, Serialize)]
pub struct LoginRequest {
    pub email: String,
    pub password: String,
}

#[derive(Debug, Deserialize)]
pub struct LoginResponse {
    pub user: UserResponse,
}

#[derive(Debug, Clone, Deserialize)]
pub struct UserResponse {
    pub id: String,
    pub email: String,
    pub name: String,
}

pub async fn login(email: &str, password: &str) -> Result<UserResponse, ApiError> {
    let request = LoginRequest {
        email: email.to_string(),
        password: password.to_string(),
    };

    let response: LoginResponse = post("/auth/login", &request).await?;
    Ok(response.user)
}

pub async fn logout() -> Result<(), ApiError> {
    post::<(), _>("/auth/logout", &()).await?;
    Ok(())
}

// frontend/src/api/users.rs
use serde::Deserialize;

use super::client::{get, ApiError};

#[derive(Debug, Clone, Deserialize)]
pub struct User {
    pub id: String,
    pub email: String,
    pub name: String,
    pub created_at: String,
}

pub async fn get_me() -> Result<User, ApiError> {
    get("/users/me").await
}

pub async fn list_users() -> Result<Vec<User>, ApiError> {
    get("/users").await
}

# shared/Cargo.toml
[dependencies]
serde = { version = "1.0", features = ["derive"] }

# バックエンド専用の依存関係は feature flag で分ける
[features]
backend = ["sqlx"]

[dependencies.sqlx]
version = "0.8"
optional = true

// バックエンド: 統一されたエラーレスポンス
#[derive(Serialize)]
struct ErrorResponse {
    error: String,
    code: Option<String>,
}

// frontend/src/api/client.rs
#[derive(Debug, Deserialize)]
struct ErrorBody {
    error: String,
    code: Option<String>,
}

pub async fn post<T: DeserializeOwned, B: Serialize>(
    path: &str,
    body: &B,
) -> Result<T, ApiError> {
    // ... リクエスト送信 ...

    if !response.ok() {
        // エラーレスポンスをパース
        let error_body: ErrorBody = response
            .json()
            .await
            .unwrap_or(ErrorBody {
                error: "Unknown error".to_string(),
                code: None,
            });

        return Err(ApiError::ApiError(error_body.error));
    }

    // ...
}

// frontend/src/context/auth.rs
#[component]
pub fn AuthProvider(children: Children) -> impl IntoView {
    let auth = AuthContext::new();
    provide_context(auth.clone());

    // 初期化時に認証状態を確認
    spawn_local({
        let auth = auth.clone();
        async move {
            // /users/me を呼んで認証状態を確認
            match crate::api::users::get_me().await {
                Ok(user) => {
                    auth.user.set(Some(User {
                        id: user.id,
                        email: user.email,
                        name: user.name,
                    }));
                }
                Err(_) => {
                    // 未認証またはトークン切れ
                    auth.user.set(None);
                }
            }
        }
    });

    children()
}

# Terraformの基本コマンド
terraform init      # 初期化（プロバイダーのダウンロード）
terraform plan      # 変更内容のプレビュー（実際には何も変更しない）
terraform apply     # 変更を適用（リソースを作成・更新）
terraform destroy   # すべてのリソースを削除

# コメントは # で始まる

# リソース定義: resource "リソースタイプ" "リソース名" { ... }
resource "google_sql_database_instance" "main" {
  name             = "my-database"      # 文字列は "..." で囲む
  database_version = "POSTGRES_17"
  region           = var.region         # var.xxx で変数を参照

  settings {                            # ネストしたブロック
    tier = "db-f1-micro"
  }
}

# 変数定義: variable "変数名" { ... }
variable "region" {
  description = "デプロイリージョン"    # 説明文
  type        = string                  # 型（string, number, bool, list, map）
  default     = "asia-northeast1"       # デフォルト値
}

# 出力値: output "出力名" { ... }
output "database_connection" {
  value = google_sql_database_instance.main.connection_name
  #       ↑ 他のリソースの属性を参照
}

resource "google_sql_database_instance" "main" {
#        ↑ プロバイダー_サービス_リソース種類   ↑ ローカル名（Terraform内で参照する名前）
  name = "my-project-db-production"
  #      ↑ 実際にGCP上に作られるリソースの名前
}

terraform/
├── main.tf           # メインの設定
├── variables.tf      # 変数定義
├── outputs.tf        # 出力値
├── cloud_sql.tf      # Cloud SQL設定
├── cloud_run.tf      # Cloud Run設定
├── artifact_registry.tf  # Artifact Registry設定
└── terraform.tfvars  # 変数の値（gitignore推奨）

# terraform/main.tf

# ============================================
# Terraform本体の設定
# ============================================
terraform {
  # Terraformのバージョン制約
  # ">= 1.5.0" は「1.5.0以上」を意味する
  required_version = ">= 1.5.0"

  # 使用するプロバイダー（クラウドサービスとの接続プラグイン）
  required_providers {
    google = {
      source  = "hashicorp/google"  # HashiCorp公式のGCPプロバイダー
      version = "~> 5.0"            # "~> 5.0" は 5.x系の最新を使う（6.0未満）
    }
  }

  # 状態ファイル（terraform.tfstate）の保存先
  # ローカルに保存すると他のPCで作業できないので、GCSに保存する
  backend "gcs" {
    bucket = "my-app-terraform-state"  # 事前にGCSバケットを作成しておく
    prefix = "terraform/state"          # バケット内のパス
  }
  # 注意: このバケットは terraform init 前に手動で作成する必要がある
  # gsutil mb -l asia-northeast1 gs://my-app-terraform-state
}

# ============================================
# GCPプロバイダーの設定
# ============================================
provider "google" {
  project = var.project_id  # 操作対象のGCPプロジェクトID
  region  = var.region      # デフォルトリージョン
  # 認証は gcloud auth application-default login で行う
  # または環境変数 GOOGLE_APPLICATION_CREDENTIALS でサービスアカウントキーを指定
}

# ============================================
# GCP APIの有効化
# ============================================
# GCPでは各サービスを使う前にAPIを有効化する必要がある
# コンソールでポチポチする代わりに、ここで宣言的に管理できる
resource "google_project_service" "services" {
  # for_each で配列の各要素に対してリソースを作成
  # toset() はリストをセット（重複なし集合）に変換
  for_each = toset([
    "run.googleapis.com",              # Cloud Run
    "sqladmin.googleapis.com",         # Cloud SQL Admin
    "artifactregistry.googleapis.com", # Artifact Registry（Dockerイメージ保存）
    "secretmanager.googleapis.com",    # Secret Manager（シークレット管理）
    "compute.googleapis.com",          # Compute Engine（VPCに必要）
    "servicenetworking.googleapis.com", # Service Networking（プライベート接続に必要）
  ])

  project = var.project_id
  service = each.key  # for_each のときは each.key で現在の要素を参照

  # terraform destroy してもAPIを無効化しない
  # 無効化すると既存のリソースに影響する可能性があるため
  disable_on_destroy = false
}

# terraform/variables.tf

# ============================================
# 必須変数（デフォルト値なし → terraform apply 時に入力必須）
# ============================================
variable "project_id" {
  description = "GCPプロジェクトID（例: my-project-123456）"
  type        = string
  # default がないので必須。terraform.tfvars か -var オプションで指定する
}

variable "environment" {
  description = "環境名（staging/production）"
  type        = string

  # バリデーション: 指定された値以外はエラー
  validation {
    condition     = contains(["staging", "production"], var.environment)
    error_message = "環境名は staging または production のみ"
  }
}

# ============================================
# オプション変数（デフォルト値あり）
# ============================================
variable "region" {
  description = "デプロイリージョン"
  type        = string
  default     = "asia-northeast1"  # 東京リージョン
  # 他の選択肢:
  # - asia-northeast2: 大阪
  # - us-central1: アイオワ（安い）
  # - europe-west1: ベルギー
}

# --------------------------------------------
# データベース設定
# --------------------------------------------
variable "db_tier" {
  description = "Cloud SQLのマシンタイプ"
  type        = string
  default     = "db-f1-micro"
  # 選択肢と目安:
  # - db-f1-micro: 共有CPU, 0.6GB RAM（無料枠、開発用）
  # - db-g1-small: 共有CPU, 1.7GB RAM（小規模本番）
  # - db-custom-1-3840: 1 vCPU, 3.75GB RAM（中規模本番）
  # - db-custom-2-7680: 2 vCPU, 7.5GB RAM（大規模本番）
}

variable "db_name" {
  description = "データベース名"
  type        = string
  default     = "app_db"
}

# --------------------------------------------
# Cloud Run設定
# --------------------------------------------
variable "backend_cpu" {
  description = "バックエンドのCPU数"
  type        = string
  default     = "1"
  # 選択肢: "1", "2", "4", "8"
  # Rustバイナリは軽いので1で十分なことが多い
}

variable "backend_memory" {
  description = "バックエンドのメモリ"
  type        = string
  default     = "512Mi"
  # 選択肢: "128Mi", "256Mi", "512Mi", "1Gi", "2Gi", "4Gi", "8Gi"
  # Rustは省メモリなので512Miで十分動く。Node.jsなら1Gi欲しい
}

# terraform/terraform.tfvars
# このファイルは .gitignore に追加すること！
# シークレットを含む可能性があるため

project_id  = "my-project-123456"
environment = "production"
region      = "asia-northeast1"

# 本番用の設定（開発時はデフォルト値を使う）
db_tier        = "db-custom-1-3840"
backend_memory = "1Gi"

# 方法1: terraform.tfvars を使う（最も一般的）
# terraform.tfvars が自動で読み込まれる
terraform apply

# 方法2: 別名のファイルを指定
terraform apply -var-file="production.tfvars"

# 方法3: コマンドラインで直接指定
terraform apply -var="project_id=my-project-123456" -var="environment=staging"

# 方法4: 環境変数（TF_VAR_ プレフィックス）
export TF_VAR_project_id="my-project-123456"
terraform apply

# terraform/network.tf

# VPCネットワーク
resource "google_compute_network" "vpc" {
  name                    = "${var.project_id}-vpc"
  auto_create_subnetworks = false  # サブネットは手動で作成

  depends_on = [google_project_service.services]
}

# サブネット（リージョンごとに作成）
resource "google_compute_subnetwork" "subnet" {
  name          = "${var.project_id}-subnet"
  ip_cidr_range = "10.0.0.0/24"  # このサブネットで使うIPアドレス範囲
  region        = var.region
  network       = google_compute_network.vpc.id
}

# プライベートIP範囲（Cloud SQLへのプライベート接続用）
resource "google_compute_global_address" "private_ip_range" {
  name          = "private-ip-range"
  purpose       = "VPC_PEERING"
  address_type  = "INTERNAL"
  prefix_length = 16            # /16 = 65,536個のIPアドレス
  network       = google_compute_network.vpc.id
}

# サービスネットワーキング接続
# これにより、Cloud SQLがVPC内のプライベートIPを持てる
resource "google_service_networking_connection" "private_vpc_connection" {
  network                 = google_compute_network.vpc.id
  service                 = "servicenetworking.googleapis.com"
  reserved_peering_ranges = [google_compute_global_address.private_ip_range.name]

  depends_on = [google_project_service.services]
}

# terraform/cloud_sql.tf

# ============================================
# Cloud SQLインスタンス（PostgreSQLサーバー本体）
# ============================================
resource "google_sql_database_instance" "main" {
  # GCP上のリソース名。変更すると再作成になるので注意
  name             = "${var.project_id}-db-${var.environment}"
  database_version = "POSTGRES_17"  # PostgreSQLのバージョン
  region           = var.region

  settings {
    # マシンタイプ（CPU・メモリ）
    tier = var.db_tier

    # ディスク設定
    disk_size       = 10    # 初期サイズ（GB）
    disk_autoresize = true  # 容量不足時に自動拡張
    disk_type       = "PD_SSD"  # SSD（高速）or PD_HDD（安い）

    # バックアップ設定（本番では必須）
    backup_configuration {
      enabled                        = true   # 自動バックアップを有効化
      point_in_time_recovery_enabled = true   # ポイントインタイムリカバリ（任意の時点に復元可能）
      start_time                     = "03:00"  # バックアップ開始時刻（UTC）

      backup_retention_settings {
        retained_backups = 7       # 保持するバックアップ数
        retention_unit   = "COUNT" # COUNTまたはDAYS
      }
    }

    # ネットワーク設定（セキュリティ重要）
    ip_configuration {
      ipv4_enabled    = false  # パブリックIPを無効化（インターネットから直接アクセス不可）
      private_network = google_compute_network.vpc.id  # VPC経由でのみアクセス可能

      # パブリックIPを有効にする場合は authorized_networks で許可IPを制限すること
      # ipv4_enabled = true
      # authorized_networks {
      #   name  = "office"
      #   value = "203.0.113.0/24"  # 許可するIPアドレス範囲
      # }
    }

    # メンテナンスウィンドウ（自動アップデートの実行時間帯）
    maintenance_window {
      day          = 7  # 1=月曜...7=日曜
      hour         = 3  # UTC 03:00 = JST 12:00（昼休み中に実行）
      update_track = "stable"  # stable or canary（早期アップデート）
    }

    # PostgreSQL設定フラグ
    database_flags {
      name  = "max_connections"
      value = "100"  # 最大同時接続数
    }
  }

  # 削除保護（本番環境では true にして誤削除を防ぐ）
  # terraform destroy で削除したい場合は、先に false に変更してから apply
  deletion_protection = var.environment == "production"

  # VPC接続が完了してから作成
  depends_on = [
    google_project_service.services,
    google_service_networking_connection.private_vpc_connection,
  ]
}

# ============================================
# データベース（PostgreSQLインスタンス内のDB）
# ============================================
resource "google_sql_database" "app" {
  name     = var.db_name  # データベース名（app_db など）
  instance = google_sql_database_instance.main.name
  # 1つのCloud SQLインスタンスに複数のデータベースを作成可能
}

# ============================================
# データベースユーザー
# ============================================
resource "google_sql_user" "app" {
  name     = "app_user"
  instance = google_sql_database_instance.main.name
  password = random_password.db_password.result
  # 注意: postgres ユーザーは使わない（スーパーユーザー権限を持つため危険）
}

# ============================================
# ランダムなパスワード生成
# ============================================
# Terraformの random プロバイダーを使用
# terraform.tfvars に書くのではなく、Terraformに生成させることでセキュリティ向上
resource "random_password" "db_password" {
  length  = 32
  special = false  # Cloud SQLのパスワードに特殊文字を含めると問題が起きることがある
}

# ============================================
# Secret Manager（シークレット管理）
# ============================================
# パスワードを Secret Manager に保存し、Cloud Run から参照する
# 環境変数に直接書くより安全

resource "google_secret_manager_secret" "db_password" {
  secret_id = "db-password-${var.environment}"

  replication {
    auto {}  # Googleに任せる（リージョン間で自動レプリケーション）
  }
}

# シークレットのバージョン（実際の値を保存）
resource "google_secret_manager_secret_version" "db_password" {
  secret      = google_secret_manager_secret.db_password.id
  secret_data = random_password.db_password.result
  # 更新するには新しいバージョンを作成する（イミュータブル）
}

# terraform/secrets.tf

# ============================================
# JWT Access Token シークレット
# ============================================
resource "random_password" "access_token_secret" {
  length  = 64
  special = true
}

resource "google_secret_manager_secret" "access_token_secret" {
  secret_id = "access-token-secret-${var.environment}"

  replication {
    auto {}
  }
}

resource "google_secret_manager_secret_version" "access_token_secret" {
  secret      = google_secret_manager_secret.access_token_secret.id
  secret_data = random_password.access_token_secret.result
}

# ============================================
# JWT Refresh Token シークレット
# ============================================
resource "random_password" "refresh_token_secret" {
  length  = 64
  special = true
}

resource "google_secret_manager_secret" "refresh_token_secret" {
  secret_id = "refresh-token-secret-${var.environment}"

  replication {
    auto {}
  }
}

resource "google_secret_manager_secret_version" "refresh_token_secret" {
  secret      = google_secret_manager_secret.refresh_token_secret.id
  secret_data = random_password.refresh_token_secret.result
}

# terraform/artifact_registry.tf

# Dockerイメージの保存先
resource "google_artifact_registry_repository" "backend" {
  location      = var.region       # イメージを保存するリージョン
  repository_id = "backend"        # リポジトリ名
  format        = "DOCKER"         # Dockerイメージ用
  description   = "Backend container images"

  # イメージのプッシュ先URL:
  # asia-northeast1-docker.pkg.dev/PROJECT_ID/backend/IMAGE_NAME:TAG
}

# 1. Docker認証を設定（初回のみ）
gcloud auth configure-docker asia-northeast1-docker.pkg.dev

# 2. イメージをビルド
docker build -t asia-northeast1-docker.pkg.dev/my-project/backend/app:v1.0.0 .

# 3. プッシュ
docker push asia-northeast1-docker.pkg.dev/my-project/backend/app:v1.0.0

# terraform/cloud_run.tf

# ============================================
# Cloud Run サービス本体
# ============================================
resource "google_cloud_run_v2_service" "backend" {
  name     = "backend-${var.environment}"  # サービス名
  location = var.region

  # template: コンテナの設定（新しいリビジョンを作るたびにこの設定が適用される）
  template {
    # --------------------------------------------
    # スケーリング設定
    # --------------------------------------------
    scaling {
      # 最小インスタンス数
      # 本番: 1（コールドスタートを避ける）
      # ステージング: 0（コスト削減、リクエスト時に起動）
      min_instance_count = var.environment == "production" ? 1 : 0

      # 最大インスタンス数（負荷に応じて自動スケール）
      max_instance_count = 10
    }

    # --------------------------------------------
    # コンテナ設定
    # --------------------------------------------
    containers {
      name  = "backend"
      # Artifact Registryのイメージを指定
      # latest タグは本番では避けるべき（バージョンタグ推奨）
      image = "${var.region}-docker.pkg.dev/${var.project_id}/backend/app:latest"

      # リソース制限（CPU・メモリ）
      resources {
        limits = {
          cpu    = var.backend_cpu     # "1", "2", etc.
          memory = var.backend_memory  # "512Mi", "1Gi", etc.
        }
        # cpu_idle: リクエスト処理中以外はCPUを割り当てない（コスト削減）
        # 欠点: バックグラウンド処理ができない
        cpu_idle = true
      }

      # コンテナがリッスンするポート
      # Cloud Runはこのポートにリクエストを転送する
      # PORT環境変数も自動で設定される
      ports {
        container_port = 8080
      }

      # --------------------------------------------
      # 環境変数（通常の値）
      # --------------------------------------------
      env {
        name  = "RUST_LOG"
        # 三項演算子: 条件 ? true時の値 : false時の値
        value = var.environment == "production" ? "info" : "debug"
      }

      # DATABASE_URL: Cloud SQL Auth Proxy経由で接続
      # Unixソケット形式: postgres://user:pass@/dbname?host=/cloudsql/CONNECTION_NAME
      env {
        name  = "DATABASE_URL"
        value = "postgres://app_user:${random_password.db_password.result}@/${var.db_name}?host=/cloudsql/${google_sql_database_instance.main.connection_name}"
      }

      # --------------------------------------------
      # 環境変数（Secret Managerから取得）
      # --------------------------------------------
      # value ではなく value_source を使うとSecret Managerから取得できる
      # セキュリティ上、シークレットは直接書かない方がいい
      env {
        name = "ACCESS_TOKEN_SECRET"
        value_source {
          secret_key_ref {
            secret  = google_secret_manager_secret.access_token_secret.id
            version = "latest"  # または特定のバージョン番号
          }
        }
      }

      env {
        name = "REFRESH_TOKEN_SECRET"
        value_source {
          secret_key_ref {
            secret  = google_secret_manager_secret.refresh_token_secret.id
            version = "latest"
          }
        }
      }

      # --------------------------------------------
      # ヘルスチェック
      # --------------------------------------------
      # startup_probe: コンテナ起動時のチェック
      # これが成功するまでリクエストを受け付けない
      startup_probe {
        http_get {
          path = "/health"  # axumで実装した /health エンドポイント
        }
        initial_delay_seconds = 5   # 起動後5秒待ってからチェック開始
        period_seconds        = 10  # 10秒ごとにチェック
        failure_threshold     = 3   # 3回失敗でコンテナ再起動
      }

      # liveness_probe: 実行中のヘルスチェック
      # 失敗が続くとコンテナが再起動される
      liveness_probe {
        http_get {
          path = "/health"
        }
        period_seconds = 30
      }

      # --------------------------------------------
      # Cloud SQL接続（Unixソケット）
      # --------------------------------------------
      # /cloudsql ディレクトリにCloud SQL Auth Proxyのソケットがマウントされる
      volume_mounts {
        name       = "cloudsql"
        mount_path = "/cloudsql"
      }
    }

    # Cloud SQL Auth Proxyボリューム
    # これにより、コンテナからCloud SQLにセキュアに接続できる
    volumes {
      name = "cloudsql"
      cloud_sql_instance {
        instances = [google_sql_database_instance.main.connection_name]
        # connection_name: PROJECT_ID:REGION:INSTANCE_NAME 形式
      }
    }

    # このコンテナが使用するサービスアカウント
    service_account = google_service_account.backend.email
  }

  # トラフィック設定
  # 新しいリビジョンにトラフィックを100%向ける
  traffic {
    type    = "TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST"
    percent = 100
    # カナリアリリースしたい場合は、複数の traffic ブロックで割合を指定
  }

  depends_on = [
    google_project_service.services,
    google_sql_database_instance.main,
  ]
}

# ============================================
# IAM（権限管理）
# ============================================
# GCPでは「誰が」「何に」「どんな操作を」できるかをIAMで制御する
# member: 誰（ユーザー、サービスアカウント）
# role: どんな操作ができるか（権限のセット）
# resource: 何に対して

# Cloud Runサービスを公開（認証なしでアクセス可能に）
resource "google_cloud_run_v2_service_iam_member" "public" {
  location = var.region
  name     = google_cloud_run_v2_service.backend.name
  role     = "roles/run.invoker"  # Cloud Runを呼び出す権限
  member   = "allUsers"           # 全員（インターネット上の誰でも）
  # 注意: 認証が必要な内部APIの場合は allUsers を使わない
}

# ============================================
# サービスアカウント
# ============================================
# サービスアカウント = アプリケーション用のGCPアカウント
# 人間のユーザーとは別に、アプリケーションがGCPリソースにアクセスするために使う
resource "google_service_account" "backend" {
  account_id   = "backend-${var.environment}"     # アカウントID（一意）
  display_name = "Backend Service Account"         # 表示名
  # メールアドレスは自動生成: backend-production@PROJECT_ID.iam.gserviceaccount.com
}

# Secret Managerへのアクセス権限を付与
# Cloud RunコンテナがJWTシークレットを読み取れるようにする
resource "google_secret_manager_secret_iam_member" "backend_access" {
  # for_each: 複数のシークレットに同じ権限を付与
  for_each = toset([
    google_secret_manager_secret.access_token_secret.id,
    google_secret_manager_secret.refresh_token_secret.id,
    google_secret_manager_secret.db_password.id,
  ])

  secret_id = each.value
  role      = "roles/secretmanager.secretAccessor"  # シークレットの読み取り権限
  member    = "serviceAccount:${google_service_account.backend.email}"
}

# Cloud SQLへのアクセス権限を付与
resource "google_project_iam_member" "backend_cloudsql" {
  project = var.project_id
  role    = "roles/cloudsql.client"  # Cloud SQLクライアント権限
  member  = "serviceAccount:${google_service_account.backend.email}"
}

# backend/Dockerfile.prod

# ============================================
# Stage 1: cargo-chef によるキャッシュ準備
# ============================================
FROM rust:1.92-bookworm AS chef
RUN cargo install cargo-chef --locked
WORKDIR /app

# ============================================
# Stage 2: 依存関係のレシピ生成
# ============================================
FROM chef AS planner
COPY . .
RUN cargo chef prepare --recipe-path recipe.json

# ============================================
# Stage 3: 依存関係のビルド（キャッシュ対象）
# ============================================
FROM chef AS builder
COPY --from=planner /app/recipe.json recipe.json
RUN cargo chef cook --release --recipe-path recipe.json

# アプリケーションのビルド
COPY . .
RUN cargo build --release --bin backend

# ============================================
# Stage 4: 最小限のランタイムイメージ
# ============================================
FROM gcr.io/distroless/cc-debian12:nonroot

WORKDIR /app

# バイナリをコピー
COPY --from=builder /app/target/release/backend /app/backend

# 非rootユーザーで実行（distrolessのnonrootタグで自動設定）
USER nonroot:nonroot

# ポート公開
EXPOSE 8080

# 起動コマンド
ENTRYPOINT ["/app/backend"]

# frontend/wrangler.toml
name = "my-app-frontend"
main = "src/lib.rs"
compatibility_date = "2026-01-01"

[assets]
directory = "dist"

// workers/api-proxy/src/lib.rs
use worker::*;

#[event(fetch)]
async fn main(req: Request, env: Env, _ctx: Context) -> Result<Response> {
    let backend_url = env.var("BACKEND_URL")?.to_string();

    // パスを取得
    let url = req.url()?;
    let path = url.path();

    // /api/* へのリクエストをバックエンドに転送
    if path.starts_with("/api/") {
        let backend_path = path.strip_prefix("/api").unwrap_or(path);
        let target_url = format!("{}{}", backend_url, backend_path);

        // リクエストを転送
        let mut headers = req.headers().clone();

        let mut init = RequestInit::new();
        init.with_method(req.method());
        init.with_headers(headers);

        if let Some(body) = req.bytes().await.ok() {
            if !body.is_empty() {
                init.with_body(Some(body.into()));
            }
        }

        let backend_req = Request::new_with_init(&target_url, &init)?;
        Fetch::Request(backend_req).send().await
    } else {
        Response::error("Not Found", 404)
    }
}

# 初回のみローカルで状態ファイルを作成後、以下のコマンドでGCSに移行
# terraform init -migrate-state

terraform {
  backend "gcs" {
    bucket = "my-app-terraform-state"
    prefix = "terraform/state"
  }
}

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main, develop]

env:
  CARGO_TERM_COLOR: always
  RUST_BACKTRACE: 1

jobs:
  check:
    name: Check & Lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt, clippy

      - name: Cache cargo registry
        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-cargo-

      - name: Check format
        run: cargo fmt --all -- --check

      - name: Clippy
        run: cargo clippy --all-targets --all-features -- -D warnings

  build:
    name: Build
    runs-on: ubuntu-latest
    needs: check
    steps:
      - uses: actions/checkout@v4

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Cache cargo registry
        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-cargo-

      - name: Build backend
        run: cargo build --release -p backend

      - name: Install trunk
        run: cargo install trunk --locked

      - name: Add wasm target
        run: rustup target add wasm32-unknown-unknown

      - name: Build frontend
        run: trunk build --release
        working-directory: ./frontend

  test:
    name: Test
    runs-on: ubuntu-latest
    needs: check
    services:
      postgres:
        image: postgres:17
        env:
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
          POSTGRES_DB: test_db
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Cache cargo registry
        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-cargo-

      - name: Install sqlx-cli
        run: cargo install sqlx-cli --no-default-features --features postgres

      - name: Run migrations
        run: sqlx migrate run
        working-directory: ./backend
        env:
          DATABASE_URL: postgres://test:test@localhost:5432/test_db

      - name: Run tests
        run: cargo test --all
        env:
          DATABASE_URL: postgres://test:test@localhost:5432/test_db
          ACCESS_TOKEN_SECRET: ${{ secrets.TEST_ACCESS_TOKEN_SECRET }}
          REFRESH_TOKEN_SECRET: ${{ secrets.TEST_REFRESH_TOKEN_SECRET }}

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    tags:
      - 'v*'

env:
  PROJECT_ID: my-gcp-project
  REGION: asia-northeast1
  BACKEND_SERVICE: backend
  FRONTEND_WORKER: my-app-frontend

jobs:
  deploy-backend:
    name: Deploy Backend
    runs-on: ubuntu-latest
    permissions:
      contents: read
      id-token: write  # Workload Identity Federation用

    steps:
      - uses: actions/checkout@v4

      - name: Get version from tag
        id: version
        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT

      # GCP認証（Workload Identity Federation推奨）
      - name: Authenticate to Google Cloud
        uses: google-github-actions/auth@v2
        with:
          workload_identity_provider: ${{ secrets.WIF_PROVIDER }}
          service_account: ${{ secrets.WIF_SERVICE_ACCOUNT }}

      - name: Set up Cloud SDK
        uses: google-github-actions/setup-gcloud@v2

      - name: Configure Docker
        run: gcloud auth configure-docker ${{ env.REGION }}-docker.pkg.dev

      # Docker イメージのビルドとプッシュ
      - name: Build and push Docker image
        run: |
          docker build \
            -f backend/Dockerfile.prod \
            -t ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.BACKEND_SERVICE }}/app:${{ steps.version.outputs.VERSION }} \
            -t ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.BACKEND_SERVICE }}/app:latest \
            .
          docker push ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.BACKEND_SERVICE }}/app:${{ steps.version.outputs.VERSION }}
          docker push ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.BACKEND_SERVICE }}/app:latest

      # Cloud Runにデプロイ
      - name: Deploy to Cloud Run
        run: |
          gcloud run deploy ${{ env.BACKEND_SERVICE }}-production \
            --image ${{ env.REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.BACKEND_SERVICE }}/app:${{ steps.version.outputs.VERSION }} \
            --region ${{ env.REGION }} \
            --platform managed

  deploy-frontend:
    name: Deploy Frontend
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Add wasm target
        run: rustup target add wasm32-unknown-unknown

      - name: Install trunk
        run: cargo install trunk --locked

      - name: Build frontend
        run: trunk build --release
        working-directory: ./frontend

      - name: Deploy to Cloudflare Workers
        uses: cloudflare/wrangler-action@v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          workingDirectory: ./frontend

  create-release:
    name: Create Release
    runs-on: ubuntu-latest
    needs: [deploy-backend, deploy-frontend]
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Generate changelog
        id: changelog
        uses: orhun/git-cliff-action@v3
        with:
          config: cliff.toml
          args: --latest --strip header

      - name: Create GitHub Release
        uses: softprops/action-gh-release@v2
        with:
          body: ${{ steps.changelog.outputs.content }}
          draft: false
          prerelease: ${{ contains(github.ref, '-rc') || contains(github.ref, '-beta') }}

# terraform/github_actions.tf

# Workload Identity Pool
resource "google_iam_workload_identity_pool" "github" {
  workload_identity_pool_id = "github-pool"
  display_name              = "GitHub Actions Pool"
  description               = "Identity pool for GitHub Actions"
}

# Workload Identity Provider
resource "google_iam_workload_identity_pool_provider" "github" {
  workload_identity_pool_id          = google_iam_workload_identity_pool.github.workload_identity_pool_id
  workload_identity_pool_provider_id = "github-provider"
  display_name                       = "GitHub Provider"

  attribute_mapping = {
    "google.subject"       = "assertion.sub"
    "attribute.actor"      = "assertion.actor"
    "attribute.repository" = "assertion.repository"
  }

  oidc {
    issuer_uri = "https://token.actions.githubusercontent.com"
  }
}

# サービスアカウントへの権限付与
resource "google_service_account_iam_member" "github_actions" {
  service_account_id = google_service_account.github_actions.name
  role               = "roles/iam.workloadIdentityUser"
  member             = "principalSet://iam.googleapis.com/${google_iam_workload_identity_pool.github.name}/attribute.repository/your-org/your-repo"
}

# GitHub Actions用サービスアカウント
resource "google_service_account" "github_actions" {
  account_id   = "github-actions"
  display_name = "GitHub Actions"
}

# 必要な権限を付与
resource "google_project_iam_member" "github_actions_roles" {
  for_each = toset([
    "roles/run.developer",
    "roles/artifactregistry.writer",
    "roles/iam.serviceAccountUser",
  ])

  project = var.project_id
  role    = each.value
  member  = "serviceAccount:${google_service_account.github_actions.email}"
}

# cliff.toml
[changelog]
header = """
# Changelog\n
"""
body = """
{% for group, commits in commits | group_by(attribute="group") %}
    ### {{ group | upper_first }}
    {% for commit in commits %}
        - {{ commit.message | upper_first }} ({{ commit.id | truncate(length=7, end="") }})\
    {% endfor %}
{% endfor %}\n
"""
trim = true

[git]
conventional_commits = true
filter_unconventional = true
commit_parsers = [
    { message = "^feat", group = "Features" },
    { message = "^fix", group = "Bug Fixes" },
    { message = "^doc", group = "Documentation" },
    { message = "^perf", group = "Performance" },
    { message = "^refactor", group = "Refactor" },
    { message = "^style", group = "Styling" },
    { message = "^test", group = "Testing" },
    { message = "^chore", group = "Miscellaneous" },
]