@dewtech/dare-cli 3.2.0 → 3.4.0

package/templates/stacks/rust-axum/src/errors.rs

@@ -1,48 +1,48 @@
-//! RFC 7807 Problem Details — uniform error shape across the API.
-use axum::{
-    http::StatusCode,
-    response::{IntoResponse, Response},
-    Json,
-};
-use serde_json::json;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum AppError {
-    #[error("invalid credentials")]
-    Unauthorized,
-    #[error("forbidden")]
-    Forbidden,
-    #[error("not found")]
-    NotFound,
-    #[error("validation failed: {0}")]
-    Validation(String),
-    #[error("conflict: {0}")]
-    Conflict(String),
-    #[error("internal: {0}")]
-    Internal(#[from] anyhow::Error),
-    #[error("database: {0}")]
-    Db(#[from] sqlx::Error),
-}
-
-impl IntoResponse for AppError {
-    fn into_response(self) -> Response {
-        let (status, title) = match &self {
-            AppError::Unauthorized => (StatusCode::UNAUTHORIZED, "Unauthorized"),
-            AppError::Forbidden => (StatusCode::FORBIDDEN, "Forbidden"),
-            AppError::NotFound => (StatusCode::NOT_FOUND, "Not Found"),
-            AppError::Validation(_) => (StatusCode::BAD_REQUEST, "Bad Request"),
-            AppError::Conflict(_) => (StatusCode::CONFLICT, "Conflict"),
-            AppError::Internal(_) | AppError::Db(_) => {
-                (StatusCode::INTERNAL_SERVER_ERROR, "Internal Server Error")
-            }
-        };
-        let body = json!({
-            "type": format!("urn:problem:{}", status.as_u16()),
-            "title": title,
-            "status": status.as_u16(),
-            "detail": self.to_string(),
-        });
-        (status, Json(body)).into_response()
-    }
-}
+//! RFC 7807 Problem Details — uniform error shape across the API.
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+use serde_json::json;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum AppError {
+    #[error("invalid credentials")]
+    Unauthorized,
+    #[error("forbidden")]
+    Forbidden,
+    #[error("not found")]
+    NotFound,
+    #[error("validation failed: {0}")]
+    Validation(String),
+    #[error("conflict: {0}")]
+    Conflict(String),
+    #[error("internal: {0}")]
+    Internal(#[from] anyhow::Error),
+    #[error("database: {0}")]
+    Db(#[from] sqlx::Error),
+}
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        let (status, title) = match &self {
+            AppError::Unauthorized => (StatusCode::UNAUTHORIZED, "Unauthorized"),
+            AppError::Forbidden => (StatusCode::FORBIDDEN, "Forbidden"),
+            AppError::NotFound => (StatusCode::NOT_FOUND, "Not Found"),
+            AppError::Validation(_) => (StatusCode::BAD_REQUEST, "Bad Request"),
+            AppError::Conflict(_) => (StatusCode::CONFLICT, "Conflict"),
+            AppError::Internal(_) | AppError::Db(_) => {
+                (StatusCode::INTERNAL_SERVER_ERROR, "Internal Server Error")
+            }
+        };
+        let body = json!({
+            "type": format!("urn:problem:{}", status.as_u16()),
+            "title": title,
+            "status": status.as_u16(),
+            "detail": self.to_string(),
+        });
+        (status, Json(body)).into_response()
+    }
+}

package/templates/stacks/rust-axum/src/handlers/auth.rs

@@ -1,48 +1,48 @@
-//! Auth handlers — POST /auth/login, GET /auth/me.
-use axum::{extract::State, http::HeaderMap, Json};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    errors::AppError,
-    middleware::auth::extract_bearer,
-    services::auth_service,
-    services::user_service,
-    SharedState,
-};
-
-#[derive(Debug, Deserialize)]
-pub struct LoginRequest {
-    pub email: String,
-    pub password: String,
-}
-
-#[derive(Debug, Serialize)]
-pub struct LoginResponse {
-    pub access_token: String,
-    pub token_type: &'static str,
-    pub expires_in: i64,
-}
-
-#[derive(Debug, Serialize)]
-pub struct MeResponse {
-    pub id: uuid::Uuid,
-    pub email: String,
-    pub role: String,
-}
-
-pub async fn login(
-    State(state): State<SharedState>,
-    Json(body): Json<LoginRequest>,
-) -> Result<Json<LoginResponse>, AppError> {
-    let (token, expires_in) = auth_service::login(&state, &body.email, &body.password).await?;
-    Ok(Json(LoginResponse { access_token: token, token_type: "Bearer", expires_in }))
-}
-
-pub async fn me(
-    State(state): State<SharedState>,
-    headers: HeaderMap,
-) -> Result<Json<MeResponse>, AppError> {
-    let claims = extract_bearer(&state.cfg, &headers)?;
-    let user = user_service::find_by_id(&state, claims.sub).await?;
-    Ok(Json(MeResponse { id: user.id, email: user.email, role: user.role }))
-}
+//! Auth handlers — POST /auth/login, GET /auth/me.
+use axum::{extract::State, http::HeaderMap, Json};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    errors::AppError,
+    middleware::auth::extract_bearer,
+    services::auth_service,
+    services::user_service,
+    SharedState,
+};
+
+#[derive(Debug, Deserialize)]
+pub struct LoginRequest {
+    pub email: String,
+    pub password: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct LoginResponse {
+    pub access_token: String,
+    pub token_type: &'static str,
+    pub expires_in: i64,
+}
+
+#[derive(Debug, Serialize)]
+pub struct MeResponse {
+    pub id: uuid::Uuid,
+    pub email: String,
+    pub role: String,
+}
+
+pub async fn login(
+    State(state): State<SharedState>,
+    Json(body): Json<LoginRequest>,
+) -> Result<Json<LoginResponse>, AppError> {
+    let (token, expires_in) = auth_service::login(&state, &body.email, &body.password).await?;
+    Ok(Json(LoginResponse { access_token: token, token_type: "Bearer", expires_in }))
+}
+
+pub async fn me(
+    State(state): State<SharedState>,
+    headers: HeaderMap,
+) -> Result<Json<MeResponse>, AppError> {
+    let claims = extract_bearer(&state.cfg, &headers)?;
+    let user = user_service::find_by_id(&state, claims.sub).await?;
+    Ok(Json(MeResponse { id: user.id, email: user.email, role: user.role }))
+}

package/templates/stacks/rust-axum/src/handlers/mod.rs

@@ -1,3 +1,3 @@
-pub mod auth;
-pub mod users;
-pub mod ws;
+pub mod auth;
+pub mod users;
+pub mod ws;

package/templates/stacks/rust-axum/src/handlers/users.rs

@@ -1,81 +1,81 @@
-//! Users handlers — GET /users, POST /users.
-use axum::{
-    extract::{Query, State},
-    http::HeaderMap,
-    Json,
-};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    errors::AppError,
-    middleware::auth::extract_bearer,
-    services::user_service,
-    SharedState,
-};
-
-#[derive(Debug, Deserialize)]
-pub struct PageQuery {
-    #[serde(default = "default_page")]
-    pub page: i64,
-    #[serde(default = "default_limit")]
-    pub limit: i64,
-}
-
-fn default_page() -> i64 { 1 }
-fn default_limit() -> i64 { 20 }
-
-#[derive(Debug, Serialize)]
-pub struct UserOut {
-    pub id: uuid::Uuid,
-    pub email: String,
-    pub role: String,
-    pub created_at: chrono::DateTime<chrono::Utc>,
-}
-
-#[derive(Debug, Serialize)]
-pub struct UserPage {
-    pub items: Vec<UserOut>,
-    pub total: i64,
-    pub page: i64,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct CreateUserRequest {
-    pub email: String,
-    pub password: String,
-    #[serde(default = "default_role")]
-    pub role: String,
-}
-
-fn default_role() -> String { "USER".to_string() }
-
-pub async fn list(
-    State(state): State<SharedState>,
-    Query(q): Query<PageQuery>,
-    headers: HeaderMap,
-) -> Result<Json<UserPage>, AppError> {
-    let _ = extract_bearer(&state.cfg, &headers)?;
-    let page = q.page.max(1);
-    let limit = q.limit.clamp(1, 100);
-    let (items, total) = user_service::page(&state, page, limit).await?;
-    Ok(Json(UserPage {
-        items: items.into_iter().map(|u| UserOut {
-            id: u.id, email: u.email, role: u.role, created_at: u.created_at,
-        }).collect(),
-        total,
-        page,
-    }))
-}
-
-pub async fn create(
-    State(state): State<SharedState>,
-    headers: HeaderMap,
-    Json(body): Json<CreateUserRequest>,
-) -> Result<Json<UserOut>, AppError> {
-    let claims = extract_bearer(&state.cfg, &headers)?;
-    if claims.role != "ADMIN" {
-        return Err(AppError::Forbidden);
-    }
-    let user = user_service::create(&state, &body.email, &body.password, &body.role).await?;
-    Ok(Json(UserOut { id: user.id, email: user.email, role: user.role, created_at: user.created_at }))
-}
+//! Users handlers — GET /users, POST /users.
+use axum::{
+    extract::{Query, State},
+    http::HeaderMap,
+    Json,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    errors::AppError,
+    middleware::auth::extract_bearer,
+    services::user_service,
+    SharedState,
+};
+
+#[derive(Debug, Deserialize)]
+pub struct PageQuery {
+    #[serde(default = "default_page")]
+    pub page: i64,
+    #[serde(default = "default_limit")]
+    pub limit: i64,
+}
+
+fn default_page() -> i64 { 1 }
+fn default_limit() -> i64 { 20 }
+
+#[derive(Debug, Serialize)]
+pub struct UserOut {
+    pub id: uuid::Uuid,
+    pub email: String,
+    pub role: String,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct UserPage {
+    pub items: Vec<UserOut>,
+    pub total: i64,
+    pub page: i64,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct CreateUserRequest {
+    pub email: String,
+    pub password: String,
+    #[serde(default = "default_role")]
+    pub role: String,
+}
+
+fn default_role() -> String { "USER".to_string() }
+
+pub async fn list(
+    State(state): State<SharedState>,
+    Query(q): Query<PageQuery>,
+    headers: HeaderMap,
+) -> Result<Json<UserPage>, AppError> {
+    let _ = extract_bearer(&state.cfg, &headers)?;
+    let page = q.page.max(1);
+    let limit = q.limit.clamp(1, 100);
+    let (items, total) = user_service::page(&state, page, limit).await?;
+    Ok(Json(UserPage {
+        items: items.into_iter().map(|u| UserOut {
+            id: u.id, email: u.email, role: u.role, created_at: u.created_at,
+        }).collect(),
+        total,
+        page,
+    }))
+}
+
+pub async fn create(
+    State(state): State<SharedState>,
+    headers: HeaderMap,
+    Json(body): Json<CreateUserRequest>,
+) -> Result<Json<UserOut>, AppError> {
+    let claims = extract_bearer(&state.cfg, &headers)?;
+    if claims.role != "ADMIN" {
+        return Err(AppError::Forbidden);
+    }
+    let user = user_service::create(&state, &body.email, &body.password, &body.role).await?;
+    Ok(Json(UserOut { id: user.id, email: user.email, role: user.role, created_at: user.created_at }))
+}

package/templates/stacks/rust-axum/src/handlers/ws.rs

@@ -1,24 +1,24 @@
-//! WebSocket echo handler using axum::extract::ws.
-use axum::{
-    extract::ws::{Message, WebSocket, WebSocketUpgrade},
-    response::IntoResponse,
-};
-
-pub async fn handler(ws: WebSocketUpgrade) -> impl IntoResponse {
-    ws.on_upgrade(echo)
-}
-
-async fn echo(mut socket: WebSocket) {
-    while let Some(Ok(msg)) = socket.recv().await {
-        match msg {
-            Message::Text(t) => {
-                let _ = socket.send(Message::Text(t)).await;
-            }
-            Message::Binary(b) => {
-                let _ = socket.send(Message::Binary(b)).await;
-            }
-            Message::Close(_) => break,
-            _ => {}
-        }
-    }
-}
+//! WebSocket echo handler using axum::extract::ws.
+use axum::{
+    extract::ws::{Message, WebSocket, WebSocketUpgrade},
+    response::IntoResponse,
+};
+
+pub async fn handler(ws: WebSocketUpgrade) -> impl IntoResponse {
+    ws.on_upgrade(echo)
+}
+
+async fn echo(mut socket: WebSocket) {
+    while let Some(Ok(msg)) = socket.recv().await {
+        match msg {
+            Message::Text(t) => {
+                let _ = socket.send(Message::Text(t)).await;
+            }
+            Message::Binary(b) => {
+                let _ = socket.send(Message::Binary(b)).await;
+            }
+            Message::Close(_) => break,
+            _ => {}
+        }
+    }
+}

package/templates/stacks/rust-axum/src/lib.rs

@@ -1,19 +1,19 @@
-//! Public crate surface — re-exported for tests and bins.
-pub mod config;
-pub mod errors;
-pub mod handlers;
-pub mod llm;
-pub mod middleware;
-pub mod models;
-pub mod repositories;
-pub mod services;
-
-use std::sync::Arc;
-
-#[derive(Clone)]
-pub struct AppState {
-    pub pool: sqlx::PgPool,
-    pub cfg: config::Config,
-}
-
-pub type SharedState = Arc<AppState>;
+//! Public crate surface — re-exported for tests and bins.
+pub mod config;
+pub mod errors;
+pub mod handlers;
+pub mod llm;
+pub mod middleware;
+pub mod models;
+pub mod repositories;
+pub mod services;
+
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct AppState {
+    pub pool: sqlx::PgPool,
+    pub cfg: config::Config,
+}
+
+pub type SharedState = Arc<AppState>;

package/templates/stacks/rust-axum/src/llm/mod.rs

@@ -1 +1 @@
-pub mod provider;
+pub mod provider;

package/templates/stacks/rust-axum/src/llm/provider.rs

@@ -1,48 +1,48 @@
-//! LLM provider abstraction. Two implementations: Dummy and OpenAi.
-//!
-//! `async-trait` is used for dyn-compatible async traits — see Cargo.toml.
-use async_trait::async_trait;
-
-#[async_trait]
-pub trait LlmProvider: Send + Sync {
-    async fn complete(&self, prompt: &str, max_tokens: usize) -> anyhow::Result<String>;
-}
-
-pub struct DummyProvider;
-
-#[async_trait]
-impl LlmProvider for DummyProvider {
-    async fn complete(&self, prompt: &str, max_tokens: usize) -> anyhow::Result<String> {
-        let n = prompt.len().min(max_tokens);
-        Ok(format!("[dummy] {}", &prompt[..n]))
-    }
-}
-
-pub struct OpenAiProvider {
-    pub api_key: String,
-    pub model: String,
-    pub base_uri: String,
-}
-
-#[async_trait]
-impl LlmProvider for OpenAiProvider {
-    async fn complete(&self, prompt: &str, max_tokens: usize) -> anyhow::Result<String> {
-        let client = reqwest::Client::new();
-        let body = serde_json::json!({
-            "model": self.model,
-            "messages": [{"role": "user", "content": prompt}],
-            "max_tokens": max_tokens
-        });
-        let res = client
-            .post(format!("{}/chat/completions", self.base_uri))
-            .bearer_auth(&self.api_key)
-            .json(&body)
-            .send()
-            .await?;
-        let v: serde_json::Value = res.json().await?;
-        Ok(v["choices"][0]["message"]["content"]
-            .as_str()
-            .unwrap_or_default()
-            .to_string())
-    }
-}
+//! LLM provider abstraction. Two implementations: Dummy and OpenAi.
+//!
+//! `async-trait` is used for dyn-compatible async traits — see Cargo.toml.
+use async_trait::async_trait;
+
+#[async_trait]
+pub trait LlmProvider: Send + Sync {
+    async fn complete(&self, prompt: &str, max_tokens: usize) -> anyhow::Result<String>;
+}
+
+pub struct DummyProvider;
+
+#[async_trait]
+impl LlmProvider for DummyProvider {
+    async fn complete(&self, prompt: &str, max_tokens: usize) -> anyhow::Result<String> {
+        let n = prompt.len().min(max_tokens);
+        Ok(format!("[dummy] {}", &prompt[..n]))
+    }
+}
+
+pub struct OpenAiProvider {
+    pub api_key: String,
+    pub model: String,
+    pub base_uri: String,
+}
+
+#[async_trait]
+impl LlmProvider for OpenAiProvider {
+    async fn complete(&self, prompt: &str, max_tokens: usize) -> anyhow::Result<String> {
+        let client = reqwest::Client::new();
+        let body = serde_json::json!({
+            "model": self.model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": max_tokens
+        });
+        let res = client
+            .post(format!("{}/chat/completions", self.base_uri))
+            .bearer_auth(&self.api_key)
+            .json(&body)
+            .send()
+            .await?;
+        let v: serde_json::Value = res.json().await?;
+        Ok(v["choices"][0]["message"]["content"]
+            .as_str()
+            .unwrap_or_default()
+            .to_string())
+    }
+}