@dewtech/dare-cli 3.3.0 → 3.4.0

package/templates/stacks/rust-axum/src/main.rs.tera

@@ -1,64 +1,64 @@
-//! {{ projectName }} — Axum API entrypoint.
-use std::{net::SocketAddr, sync::Arc};
-
-use axum::{routing::{get, post}, Router};
-use sqlx::postgres::PgPoolOptions;
-use tower_http::{cors::CorsLayer, trace::TraceLayer};
-use tracing_subscriber::EnvFilter;
-
-use {{ crateName }}::{
-    config::Config,
-    handlers::{auth, users, ws},
-    middleware::rate_limit::with_rate_limit,
-    AppState,
-};
-
-#[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    dotenvy::dotenv().ok();
-    tracing_subscriber::fmt()
-        .with_env_filter(EnvFilter::from_default_env())
-        .init();
-
-    let cfg = Config::from_env()?;
-
-    let pool = PgPoolOptions::new()
-        .max_connections(10)
-        .connect(&cfg.database_url)
-        .await?;
-
-    sqlx::migrate!("./migrations").run(&pool).await?;
-
-    let state = Arc::new(AppState { pool, cfg: cfg.clone() });
-
-    let cors = CorsLayer::new()
-        .allow_origin(cfg.cors_layer_origins())
-        .allow_methods(tower_http::cors::Any)
-        .allow_headers(tower_http::cors::Any);
-
-    let app = Router::new()
-        .route("/healthz", get(|| async { "ok" }))
-        .route("/auth/login", post(auth::login))
-        .route("/auth/me", get(auth::me))
-        .route("/users", get(users::list).post(users::create))
-        .route("/ws", get(ws::handler))
-        .route("/openapi.json", get(serve_openapi))
-        .layer(cors)
-        .layer(TraceLayer::new_for_http())
-        .with_state(state);
-
-    // Rate limit applied via helper (avoids naming GovernorLayer generics).
-    let app = with_rate_limit(app, &cfg);
-
-    let addr: SocketAddr = ([0, 0, 0, 0], cfg.app_port).into();
-    tracing::info!("listening on {}", addr);
-    let listener = tokio::net::TcpListener::bind(addr).await?;
-    axum::serve(listener, app).await?;
-    Ok(())
-}
-
-async fn serve_openapi() -> axum::response::Json<serde_json::Value> {
-    let raw = include_str!("../openapi.json");
-    let v: serde_json::Value = serde_json::from_str(raw).unwrap_or_default();
-    axum::response::Json(v)
-}
+//! {{ projectName }} — Axum API entrypoint.
+use std::{net::SocketAddr, sync::Arc};
+
+use axum::{routing::{get, post}, Router};
+use sqlx::postgres::PgPoolOptions;
+use tower_http::{cors::CorsLayer, trace::TraceLayer};
+use tracing_subscriber::EnvFilter;
+
+use {{ crateName }}::{
+    config::Config,
+    handlers::{auth, users, ws},
+    middleware::rate_limit::with_rate_limit,
+    AppState,
+};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    dotenvy::dotenv().ok();
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .init();
+
+    let cfg = Config::from_env()?;
+
+    let pool = PgPoolOptions::new()
+        .max_connections(10)
+        .connect(&cfg.database_url)
+        .await?;
+
+    sqlx::migrate!("./migrations").run(&pool).await?;
+
+    let state = Arc::new(AppState { pool, cfg: cfg.clone() });
+
+    let cors = CorsLayer::new()
+        .allow_origin(cfg.cors_layer_origins())
+        .allow_methods(tower_http::cors::Any)
+        .allow_headers(tower_http::cors::Any);
+
+    let app = Router::new()
+        .route("/healthz", get(|| async { "ok" }))
+        .route("/auth/login", post(auth::login))
+        .route("/auth/me", get(auth::me))
+        .route("/users", get(users::list).post(users::create))
+        .route("/ws", get(ws::handler))
+        .route("/openapi.json", get(serve_openapi))
+        .layer(cors)
+        .layer(TraceLayer::new_for_http())
+        .with_state(state);
+
+    // Rate limit applied via helper (avoids naming GovernorLayer generics).
+    let app = with_rate_limit(app, &cfg);
+
+    let addr: SocketAddr = ([0, 0, 0, 0], cfg.app_port).into();
+    tracing::info!("listening on {}", addr);
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    axum::serve(listener, app).await?;
+    Ok(())
+}
+
+async fn serve_openapi() -> axum::response::Json<serde_json::Value> {
+    let raw = include_str!("../openapi.json");
+    let v: serde_json::Value = serde_json::from_str(raw).unwrap_or_default();
+    axum::response::Json(v)
+}

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

@@ -1,20 +1,20 @@
-//! Bearer JWT extractor — reads Authorization header and validates the token.
-use axum::http::{header::AUTHORIZATION, HeaderMap};
-use jsonwebtoken::{decode, DecodingKey, Validation};
-
-use crate::{config::Config, errors::AppError, services::auth_service::Claims};
-
-pub fn extract_bearer(cfg: &Config, headers: &HeaderMap) -> Result<Claims, AppError> {
-    let raw = headers
-        .get(AUTHORIZATION)
-        .and_then(|v| v.to_str().ok())
-        .ok_or(AppError::Unauthorized)?;
-    let token = raw.strip_prefix("Bearer ").ok_or(AppError::Unauthorized)?;
-    let data = decode::<Claims>(
-        token,
-        &DecodingKey::from_secret(cfg.jwt_secret.as_bytes()),
-        &Validation::default(),
-    )
-    .map_err(|_| AppError::Unauthorized)?;
-    Ok(data.claims)
-}
+//! Bearer JWT extractor — reads Authorization header and validates the token.
+use axum::http::{header::AUTHORIZATION, HeaderMap};
+use jsonwebtoken::{decode, DecodingKey, Validation};
+
+use crate::{config::Config, errors::AppError, services::auth_service::Claims};
+
+pub fn extract_bearer(cfg: &Config, headers: &HeaderMap) -> Result<Claims, AppError> {
+    let raw = headers
+        .get(AUTHORIZATION)
+        .and_then(|v| v.to_str().ok())
+        .ok_or(AppError::Unauthorized)?;
+    let token = raw.strip_prefix("Bearer ").ok_or(AppError::Unauthorized)?;
+    let data = decode::<Claims>(
+        token,
+        &DecodingKey::from_secret(cfg.jwt_secret.as_bytes()),
+        &Validation::default(),
+    )
+    .map_err(|_| AppError::Unauthorized)?;
+    Ok(data.claims)
+}

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

@@ -1,2 +1,2 @@
-pub mod auth;
-pub mod rate_limit;
+pub mod auth;
+pub mod rate_limit;

package/templates/stacks/rust-axum/src/middleware/rate_limit.rs

@@ -1,27 +1,27 @@
-//! Rate limit via tower_governor — per-IP token bucket.
-//!
-//! We apply the layer through a generic helper instead of naming the
-//! `GovernorLayer<K, M>` generics explicitly — the concrete extractor /
-//! middleware types vary across tower_governor versions, so we let type
-//! inference fill them in.
-use std::sync::Arc;
-
-use axum::Router;
-use tower_governor::{governor::GovernorConfigBuilder, GovernorLayer};
-
-use crate::config::Config;
-
-/// Apply the per-IP rate limit layer to a router.
-pub fn with_rate_limit<S>(router: Router<S>, cfg: &Config) -> Router<S>
-where
-    S: Clone + Send + Sync + 'static,
-{
-    let conf = Arc::new(
-        GovernorConfigBuilder::default()
-            .per_second(cfg.rate_limit_per_sec)
-            .burst_size(cfg.rate_limit_burst)
-            .finish()
-            .expect("valid governor config"),
-    );
-    router.layer(GovernorLayer { config: conf })
-}
+//! Rate limit via tower_governor — per-IP token bucket.
+//!
+//! We apply the layer through a generic helper instead of naming the
+//! `GovernorLayer<K, M>` generics explicitly — the concrete extractor /
+//! middleware types vary across tower_governor versions, so we let type
+//! inference fill them in.
+use std::sync::Arc;
+
+use axum::Router;
+use tower_governor::{governor::GovernorConfigBuilder, GovernorLayer};
+
+use crate::config::Config;
+
+/// Apply the per-IP rate limit layer to a router.
+pub fn with_rate_limit<S>(router: Router<S>, cfg: &Config) -> Router<S>
+where
+    S: Clone + Send + Sync + 'static,
+{
+    let conf = Arc::new(
+        GovernorConfigBuilder::default()
+            .per_second(cfg.rate_limit_per_sec)
+            .burst_size(cfg.rate_limit_burst)
+            .finish()
+            .expect("valid governor config"),
+    );
+    router.layer(GovernorLayer { config: conf })
+}

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

@@ -1 +1 @@
-pub mod user;
+pub mod user;

package/templates/stacks/rust-axum/src/models/user.rs

@@ -1,13 +1,13 @@
-//! User domain model. sqlx FromRow + serde Serialize.
-use serde::{Deserialize, Serialize};
-use sqlx::FromRow;
-
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
-pub struct User {
-    pub id: uuid::Uuid,
-    pub email: String,
-    pub password: String,
-    pub role: String,
-    pub created_at: chrono::DateTime<chrono::Utc>,
-    pub updated_at: chrono::DateTime<chrono::Utc>,
-}
+//! User domain model. sqlx FromRow + serde Serialize.
+use serde::{Deserialize, Serialize};
+use sqlx::FromRow;
+
+#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
+pub struct User {
+    pub id: uuid::Uuid,
+    pub email: String,
+    pub password: String,
+    pub role: String,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub updated_at: chrono::DateTime<chrono::Utc>,
+}

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

@@ -1 +1 @@
-pub mod user_repository;
+pub mod user_repository;

package/templates/stacks/rust-axum/src/repositories/user_repository.rs

@@ -1,62 +1,62 @@
-//! User repository — the only place sqlx is called for the User aggregate.
-use sqlx::PgPool;
-use uuid::Uuid;
-
-use crate::models::user::User;
-
-pub async fn find_by_email(pool: &PgPool, email: &str) -> Result<Option<User>, sqlx::Error> {
-    sqlx::query_as::<_, User>(
-        "SELECT id, email, password, role, created_at, updated_at \
-         FROM users WHERE email = $1",
-    )
-    .bind(email)
-    .fetch_optional(pool)
-    .await
-}
-
-pub async fn find_by_id(pool: &PgPool, id: Uuid) -> Result<Option<User>, sqlx::Error> {
-    sqlx::query_as::<_, User>(
-        "SELECT id, email, password, role, created_at, updated_at \
-         FROM users WHERE id = $1",
-    )
-    .bind(id)
-    .fetch_optional(pool)
-    .await
-}
-
-pub async fn page(pool: &PgPool, offset: i64, limit: i64) -> Result<Vec<User>, sqlx::Error> {
-    sqlx::query_as::<_, User>(
-        "SELECT id, email, password, role, created_at, updated_at \
-         FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2",
-    )
-    .bind(limit)
-    .bind(offset)
-    .fetch_all(pool)
-    .await
-}
-
-pub async fn count(pool: &PgPool) -> Result<i64, sqlx::Error> {
-    let row: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users")
-        .fetch_one(pool)
-        .await?;
-    Ok(row.0)
-}
-
-pub async fn create(
-    pool: &PgPool,
-    email: &str,
-    password_hash: &str,
-    role: &str,
-) -> Result<User, sqlx::Error> {
-    sqlx::query_as::<_, User>(
-        "INSERT INTO users (id, email, password, role) \
-         VALUES ($1, $2, $3, $4) \
-         RETURNING id, email, password, role, created_at, updated_at",
-    )
-    .bind(Uuid::new_v4())
-    .bind(email)
-    .bind(password_hash)
-    .bind(role)
-    .fetch_one(pool)
-    .await
-}
+//! User repository — the only place sqlx is called for the User aggregate.
+use sqlx::PgPool;
+use uuid::Uuid;
+
+use crate::models::user::User;
+
+pub async fn find_by_email(pool: &PgPool, email: &str) -> Result<Option<User>, sqlx::Error> {
+    sqlx::query_as::<_, User>(
+        "SELECT id, email, password, role, created_at, updated_at \
+         FROM users WHERE email = $1",
+    )
+    .bind(email)
+    .fetch_optional(pool)
+    .await
+}
+
+pub async fn find_by_id(pool: &PgPool, id: Uuid) -> Result<Option<User>, sqlx::Error> {
+    sqlx::query_as::<_, User>(
+        "SELECT id, email, password, role, created_at, updated_at \
+         FROM users WHERE id = $1",
+    )
+    .bind(id)
+    .fetch_optional(pool)
+    .await
+}
+
+pub async fn page(pool: &PgPool, offset: i64, limit: i64) -> Result<Vec<User>, sqlx::Error> {
+    sqlx::query_as::<_, User>(
+        "SELECT id, email, password, role, created_at, updated_at \
+         FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2",
+    )
+    .bind(limit)
+    .bind(offset)
+    .fetch_all(pool)
+    .await
+}
+
+pub async fn count(pool: &PgPool) -> Result<i64, sqlx::Error> {
+    let row: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users")
+        .fetch_one(pool)
+        .await?;
+    Ok(row.0)
+}
+
+pub async fn create(
+    pool: &PgPool,
+    email: &str,
+    password_hash: &str,
+    role: &str,
+) -> Result<User, sqlx::Error> {
+    sqlx::query_as::<_, User>(
+        "INSERT INTO users (id, email, password, role) \
+         VALUES ($1, $2, $3, $4) \
+         RETURNING id, email, password, role, created_at, updated_at",
+    )
+    .bind(Uuid::new_v4())
+    .bind(email)
+    .bind(password_hash)
+    .bind(role)
+    .fetch_one(pool)
+    .await
+}

package/templates/stacks/rust-axum/src/services/auth_service.rs

@@ -1,50 +1,50 @@
-//! Auth business logic — login flow.
-use argon2::{
-    password_hash::{PasswordHash, PasswordVerifier},
-    Argon2,
-};
-use chrono::Utc;
-use jsonwebtoken::{encode, EncodingKey, Header};
-use serde::{Deserialize, Serialize};
-
-use crate::{errors::AppError, repositories::user_repository, SharedState};
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Claims {
-    pub sub: uuid::Uuid,
-    pub email: String,
-    pub role: String,
-    pub exp: i64,
-}
-
-pub async fn login(
-    state: &SharedState,
-    email: &str,
-    password: &str,
-) -> Result<(String, i64), AppError> {
-    let email = email.trim().to_lowercase();
-    let user = user_repository::find_by_email(&state.pool, &email).await?
-        .ok_or(AppError::Unauthorized)?;
-
-    let parsed = PasswordHash::new(&user.password)
-        .map_err(|_| AppError::Unauthorized)?;
-    Argon2::default()
-        .verify_password(password.as_bytes(), &parsed)
-        .map_err(|_| AppError::Unauthorized)?;
-
-    let exp = Utc::now().timestamp() + state.cfg.jwt_expires_secs;
-    let claims = Claims {
-        sub: user.id,
-        email: user.email.clone(),
-        role: user.role.clone(),
-        exp,
-    };
-    let token = encode(
-        &Header::default(),
-        &claims,
-        &EncodingKey::from_secret(state.cfg.jwt_secret.as_bytes()),
-    )
-    .map_err(|e| AppError::Internal(anyhow::anyhow!(e)))?;
-
-    Ok((token, state.cfg.jwt_expires_secs))
-}
+//! Auth business logic — login flow.
+use argon2::{
+    password_hash::{PasswordHash, PasswordVerifier},
+    Argon2,
+};
+use chrono::Utc;
+use jsonwebtoken::{encode, EncodingKey, Header};
+use serde::{Deserialize, Serialize};
+
+use crate::{errors::AppError, repositories::user_repository, SharedState};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Claims {
+    pub sub: uuid::Uuid,
+    pub email: String,
+    pub role: String,
+    pub exp: i64,
+}
+
+pub async fn login(
+    state: &SharedState,
+    email: &str,
+    password: &str,
+) -> Result<(String, i64), AppError> {
+    let email = email.trim().to_lowercase();
+    let user = user_repository::find_by_email(&state.pool, &email).await?
+        .ok_or(AppError::Unauthorized)?;
+
+    let parsed = PasswordHash::new(&user.password)
+        .map_err(|_| AppError::Unauthorized)?;
+    Argon2::default()
+        .verify_password(password.as_bytes(), &parsed)
+        .map_err(|_| AppError::Unauthorized)?;
+
+    let exp = Utc::now().timestamp() + state.cfg.jwt_expires_secs;
+    let claims = Claims {
+        sub: user.id,
+        email: user.email.clone(),
+        role: user.role.clone(),
+        exp,
+    };
+    let token = encode(
+        &Header::default(),
+        &claims,
+        &EncodingKey::from_secret(state.cfg.jwt_secret.as_bytes()),
+    )
+    .map_err(|e| AppError::Internal(anyhow::anyhow!(e)))?;
+
+    Ok((token, state.cfg.jwt_expires_secs))
+}

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

@@ -1,2 +1,2 @@
-pub mod auth_service;
-pub mod user_service;
+pub mod auth_service;
+pub mod user_service;

package/templates/stacks/rust-axum/src/services/user_service.rs

@@ -1,53 +1,53 @@
-//! User business logic — find / page / create.
-use argon2::{
-    password_hash::{rand_core::OsRng, PasswordHasher, SaltString},
-    Argon2,
-};
-use uuid::Uuid;
-
-use crate::{
-    errors::AppError,
-    models::user::User,
-    repositories::user_repository,
-    SharedState,
-};
-
-pub async fn find_by_id(state: &SharedState, id: Uuid) -> Result<User, AppError> {
-    user_repository::find_by_id(&state.pool, id).await?
-        .ok_or(AppError::NotFound)
-}
-
-pub async fn page(state: &SharedState, page: i64, limit: i64) -> Result<(Vec<User>, i64), AppError> {
-    let offset = (page - 1) * limit;
-    let items = user_repository::page(&state.pool, offset, limit).await?;
-    let total = user_repository::count(&state.pool).await?;
-    Ok((items, total))
-}
-
-pub async fn create(
-    state: &SharedState,
-    email: &str,
-    password: &str,
-    role: &str,
-) -> Result<User, AppError> {
-    if !["USER", "ADMIN"].contains(&role) {
-        return Err(AppError::Validation(format!("role '{}' is not allowed", role)));
-    }
-    if password.len() < 8 {
-        return Err(AppError::Validation("password must be at least 8 chars".into()));
-    }
-
-    let email = email.trim().to_lowercase();
-    if user_repository::find_by_email(&state.pool, &email).await?.is_some() {
-        return Err(AppError::Conflict("email already in use".into()));
-    }
-
-    let salt = SaltString::generate(&mut OsRng);
-    let hash = Argon2::default()
-        .hash_password(password.as_bytes(), &salt)
-        .map_err(|e| AppError::Internal(anyhow::anyhow!(e.to_string())))?
-        .to_string();
-
-    let user = user_repository::create(&state.pool, &email, &hash, role).await?;
-    Ok(user)
-}
+//! User business logic — find / page / create.
+use argon2::{
+    password_hash::{rand_core::OsRng, PasswordHasher, SaltString},
+    Argon2,
+};
+use uuid::Uuid;
+
+use crate::{
+    errors::AppError,
+    models::user::User,
+    repositories::user_repository,
+    SharedState,
+};
+
+pub async fn find_by_id(state: &SharedState, id: Uuid) -> Result<User, AppError> {
+    user_repository::find_by_id(&state.pool, id).await?
+        .ok_or(AppError::NotFound)
+}
+
+pub async fn page(state: &SharedState, page: i64, limit: i64) -> Result<(Vec<User>, i64), AppError> {
+    let offset = (page - 1) * limit;
+    let items = user_repository::page(&state.pool, offset, limit).await?;
+    let total = user_repository::count(&state.pool).await?;
+    Ok((items, total))
+}
+
+pub async fn create(
+    state: &SharedState,
+    email: &str,
+    password: &str,
+    role: &str,
+) -> Result<User, AppError> {
+    if !["USER", "ADMIN"].contains(&role) {
+        return Err(AppError::Validation(format!("role '{}' is not allowed", role)));
+    }
+    if password.len() < 8 {
+        return Err(AppError::Validation("password must be at least 8 chars".into()));
+    }
+
+    let email = email.trim().to_lowercase();
+    if user_repository::find_by_email(&state.pool, &email).await?.is_some() {
+        return Err(AppError::Conflict("email already in use".into()));
+    }
+
+    let salt = SaltString::generate(&mut OsRng);
+    let hash = Argon2::default()
+        .hash_password(password.as_bytes(), &salt)
+        .map_err(|e| AppError::Internal(anyhow::anyhow!(e.to_string())))?
+        .to_string();
+
+    let user = user_repository::create(&state.pool, &email, &hash, role).await?;
+    Ok(user)
+}

package/templates/stacks/rust-axum/tests/integration_test.rs.tera

@@ -1,13 +1,13 @@
-//! Smoke integration test. Exercises pure functions that don't need a DB.
-//!
-//! Full HTTP tests require a Postgres instance and live binding — keep those
-//! gated behind `#[ignore]` so `cargo test` stays fast in CI without infra.
-
-#[test]
-fn config_defaults_are_sane() {
-    std::env::set_var("DATABASE_URL", "postgres://user:pass@localhost:5432/x");
-    let cfg = {{ crateName }}::config::Config::from_env().expect("config");
-    assert_eq!(cfg.app_port, 8000);
-    assert!(cfg.rate_limit_per_sec > 0);
-    assert!(cfg.rate_limit_burst >= cfg.rate_limit_per_sec as u32);
-}
+//! Smoke integration test. Exercises pure functions that don't need a DB.
+//!
+//! Full HTTP tests require a Postgres instance and live binding — keep those
+//! gated behind `#[ignore]` so `cargo test` stays fast in CI without infra.
+
+#[test]
+fn config_defaults_are_sane() {
+    std::env::set_var("DATABASE_URL", "postgres://user:pass@localhost:5432/x");
+    let cfg = {{ crateName }}::config::Config::from_env().expect("config");
+    assert_eq!(cfg.app_port, 8000);
+    assert!(cfg.rate_limit_per_sec > 0);
+    assert!(cfg.rate_limit_burst >= cfg.rate_limit_per_sec as u32);
+}

package/dist/commands/new.d.ts

@@ -1,16 +0,0 @@
-/**
- * DARE v3.0 — `dare new` command
- *
- * Creates a new project from a DARE stack scaffold.
- * Currently supported stacks:
- *   - rails   → ruby-rails-8 (Rails 8 + Layered Design + OpenAPI + LLM + Action Cable)
- *
- * Usage:
- *   dare new myapp --stack rails
- *   dare new myapp --stack rails --llm openai --skip-examples
- *
- * License: MIT (D-001)
- */
-import { Command } from 'commander';
-export declare const newCommand: Command;
-//# sourceMappingURL=new.d.ts.map

package/dist/commands/new.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"new.d.ts","sourceRoot":"","sources":["../../src/commands/new.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,eAAO,MAAM,UAAU,SAgInB,CAAC"}