@dewtech/dare-cli 3.0.0 → 3.1.0

package/templates/stacks/ruby-rails-8/spec/services/create_user_service_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — CreateUserService spec
+# Convention (ADR-06): unit tests with injected doubles — no database, no network
+require "rails_helper"
+
+RSpec.describe Services::CreateUserService do
+  subject(:service) do
+    described_class.new(
+      user_repository: user_repository,
+      event_publisher: event_publisher
+    )
+  end
+
+  let(:user_repository) { instance_double(Repositories::UserRepository) }
+  let(:event_publisher) { instance_double(RealtimeService) }
+  let(:created_user)    { instance_double(User, id: 1, email: "alice@example.com", name: "Alice") }
+
+  before do
+    allow(event_publisher).to receive(:publish)
+  end
+
+  describe "#execute" do
+    context "with valid params and no existing user" do
+      before do
+        allow(user_repository).to receive(:find_by_email).with("alice@example.com").and_return(nil)
+        allow(user_repository).to receive(:build).and_return(created_user)
+        allow(created_user).to receive(:password=)
+        allow(user_repository).to receive(:save!).with(created_user).and_return(created_user)
+      end
+
+      it "returns the created user" do
+        result = service.execute(email: "alice@example.com", name: "Alice")
+        expect(result).to eq created_user
+      end
+
+      it "publishes a user.created event" do
+        service.execute(email: "alice@example.com", name: "Alice")
+        expect(event_publisher).to have_received(:publish).with(
+          type: "user.created",
+          data: hash_including(user_id: 1, email: "alice@example.com")
+        )
+      end
+
+      it "normalizes email to lowercase" do
+        allow(user_repository).to receive(:find_by_email).with("alice@example.com").and_return(nil)
+        allow(user_repository).to receive(:build).with(hash_including(email: "alice@example.com")).and_return(created_user)
+        allow(user_repository).to receive(:save!).and_return(created_user)
+
+        service.execute(email: "ALICE@EXAMPLE.COM", name: "Alice")
+
+        expect(user_repository).to have_received(:build).with(hash_including(email: "alice@example.com"))
+      end
+    end
+
+    context "when email is already taken" do
+      before do
+        allow(user_repository).to receive(:find_by_email).with("alice@example.com").and_return(created_user)
+      end
+
+      it "raises EmailTakenError" do
+        expect {
+          service.execute(email: "alice@example.com", name: "Alice")
+        }.to raise_error(Services::CreateUserService::EmailTakenError, /already registered/)
+      end
+
+      it "does not publish any event" do
+        service.execute(email: "alice@example.com", name: "Alice") rescue nil
+        expect(event_publisher).not_to have_received(:publish)
+      end
+    end
+
+    context "when repository save fails" do
+      before do
+        allow(user_repository).to receive(:find_by_email).and_return(nil)
+        allow(user_repository).to receive(:build).and_return(created_user)
+        allow(created_user).to receive(:password=)
+        allow(user_repository).to receive(:save!).and_raise(ActiveRecord::RecordInvalid)
+      end
+
+      it "propagates the error" do
+        expect {
+          service.execute(email: "alice@example.com", name: "Alice")
+        }.to raise_error(ActiveRecord::RecordInvalid)
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/services/summarize_document_service_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — SummarizeDocumentService spec
+# Convention (ADR-06): unit tests with injected doubles — no database, no network
+require "rails_helper"
+
+RSpec.describe Services::SummarizeDocumentService do
+  subject(:service) do
+    described_class.new(
+      document_repository: document_repository,
+      llm_provider:        llm_provider,
+      event_publisher:     event_publisher
+    )
+  end
+
+  let(:document_repository) { instance_double(Repositories::DocumentRepository) }
+  let(:llm_provider)        { instance_double(LLM::Providers::LLMProvider) }
+  let(:event_publisher)     { instance_double(RealtimeService) }
+
+  let(:document) do
+    instance_double(Document,
+      id:      "doc-123",
+      content: "This is a very long document that needs summarizing."
+    )
+  end
+
+  let(:summary_text) { "Short summary of the document." }
+
+  before do
+    allow(LLM::Prompts::PromptLoader).to receive(:load).and_return("rendered prompt")
+    allow(event_publisher).to receive(:publish)
+  end
+
+  describe "#execute" do
+    context "with valid document" do
+      before do
+        allow(document_repository).to receive(:find).with("doc-123").and_return(document)
+        allow(llm_provider).to receive(:complete).and_return(summary_text)
+        allow(document_repository).to receive(:update_summary!).with(document, summary_text).and_return(document)
+      end
+
+      it "returns a Result with summary and document_id" do
+        result = service.execute(document_id: "doc-123", user_id: 42)
+
+        expect(result).to be_a(Services::SummarizeDocumentService::Result)
+        expect(result.summary).to eq(summary_text)
+        expect(result.document_id).to eq("doc-123")
+      end
+
+      it "persists the summary via repository" do
+        service.execute(document_id: "doc-123", user_id: 42)
+
+        expect(document_repository).to have_received(:update_summary!).with(document, summary_text)
+      end
+
+      it "publishes a document.summarized event" do
+        service.execute(document_id: "doc-123", user_id: 42)
+
+        expect(event_publisher).to have_received(:publish).with(
+          type: "document.summarized",
+          data: hash_including(
+            document_id: "doc-123",
+            user_id:     42,
+            summary_length: summary_text.length
+          )
+        )
+      end
+
+      it "calls PromptLoader with document content and language" do
+        service.execute(document_id: "doc-123", user_id: 42)
+
+        expect(LLM::Prompts::PromptLoader).to have_received(:load).with(
+          "summarize_v1",
+          content:  document.content,
+          language: "pt-BR"
+        )
+      end
+    end
+
+    context "when document is not found" do
+      before do
+        allow(document_repository).to receive(:find).with("missing-id").and_return(nil)
+      end
+
+      it "raises DocumentNotFoundError" do
+        expect {
+          service.execute(document_id: "missing-id", user_id: 42)
+        }.to raise_error(Services::SummarizeDocumentService::DocumentNotFoundError, /missing-id/)
+      end
+
+      it "does not call the LLM provider" do
+        service.execute(document_id: "missing-id", user_id: 42) rescue nil
+
+        expect(llm_provider).not_to have_received(:complete)
+      end
+
+      it "does not publish any event" do
+        service.execute(document_id: "missing-id", user_id: 42) rescue nil
+
+        expect(event_publisher).not_to have_received(:publish)
+      end
+    end
+
+    context "when LLM returns blank response" do
+      before do
+        allow(document_repository).to receive(:find).with("doc-123").and_return(document)
+        allow(llm_provider).to receive(:complete).and_return("")
+      end
+
+      it "raises SummarizationError" do
+        expect {
+          service.execute(document_id: "doc-123", user_id: 42)
+        }.to raise_error(Services::SummarizeDocumentService::SummarizationError, /empty summary/)
+      end
+
+      it "does not persist any summary" do
+        service.execute(document_id: "doc-123", user_id: 42) rescue nil
+
+        expect(document_repository).not_to have_received(:update_summary!)
+      end
+
+      it "does not publish any event" do
+        service.execute(document_id: "doc-123", user_id: 42) rescue nil
+
+        expect(event_publisher).not_to have_received(:publish)
+      end
+    end
+
+    context "when LLM returns nil" do
+      before do
+        allow(document_repository).to receive(:find).with("doc-123").and_return(document)
+        allow(llm_provider).to receive(:complete).and_return(nil)
+      end
+
+      it "raises SummarizationError" do
+        expect {
+          service.execute(document_id: "doc-123", user_id: 42)
+        }.to raise_error(Services::SummarizeDocumentService::SummarizationError)
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/swagger_helper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — rswag swagger_helper
+# Defines OpenAPI spec structure; schemas are auto-generated from rswag specs
+
+require "rails_helper"
+
+RSpec.configure do |config|
+  # Specify a root folder where Swagger JSON files are generated
+  config.openapi_root = Rails.root.join("public").to_s
+
+  config.openapi_specs = {
+    "openapi.json" => {
+      openapi: "3.0.1",
+      info: {
+        title: "API",
+        version: "v1",
+        description: "Rails 8 API built with DARE v3.0 methodology",
+        contact: {
+          name: "API Support",
+          url:  "https://github.com/dewtech-technologies/dare-method"
+        }
+      },
+      paths:      {},
+      servers: [
+        { url: "http://localhost:3000", description: "Development" },
+        { url: "https://api.example.com", description: "Production" }
+      ],
+      components: {
+        schemas: {
+          ProblemDetails: {
+            type:       :object,
+            required:   %w[type title status],
+            properties: {
+              type:     { type: :string, description: "URI reference identifying problem type" },
+              title:    { type: :string, description: "Short, human-readable summary" },
+              status:   { type: :integer, description: "HTTP status code" },
+              detail:   { type: :string, description: "Human-readable explanation" },
+              instance: { type: :string, description: "URI reference to the specific occurrence" }
+            },
+            example: {
+              type:     "https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
+              title:    "Not Found",
+              status:   404,
+              detail:   "User with id=99 was not found.",
+              instance: "/api/users/99"
+            }
+          },
+          User: {
+            type:       :object,
+            properties: {
+              id:         { type: :integer },
+              email:      { type: :string },
+              name:       { type: :string },
+              active:     { type: :boolean },
+              created_at: { type: :string, format: "date-time" },
+              updated_at: { type: :string, format: "date-time" }
+            }
+          }
+        },
+        securitySchemes: {
+          bearerAuth: {
+            type:         :http,
+            scheme:       :bearer,
+            bearerFormat: "JWT"
+          }
+        }
+      }
+    }
+  }
+
+  config.openapi_format = :json
+end

package/templates/stacks/rust-axum/.dare/skills.yml

@@ -0,0 +1,11 @@
+version: 1
+skills:
+  - id: skill-axum-api
+    source: skill-axum-api
+    description: Axum 0.7 + Tower + utoipa + sqlx Layered Design
+  - id: dare-ax
+    source: dare-ax
+    description: Agent eXperience invariants (llms.txt, OpenAPI, --json, rate limit)
+  - id: dare-layered-design
+    source: dare-layered-design
+    description: Handler → Service → Repository → Model 4-layer architecture

package/templates/stacks/rust-axum/.env.example

@@ -0,0 +1,26 @@
+# Application
+APP_PORT=8000
+RUST_LOG=info
+
+# Database
+DATABASE_URL=postgres://user:pass@localhost:5432/myapi
+
+# JWT auth
+JWT_SECRET=replace-me-in-prod
+JWT_EXPIRES_SECS=900
+
+# Argon2 (uses sensible defaults; tune for production)
+ARGON2_MEM_KIB=19456
+ARGON2_TIME_COST=2
+ARGON2_PARALLELISM=1
+
+# Rate limit
+RATE_LIMIT_PER_SEC=10
+RATE_LIMIT_BURST=20
+
+# CORS — comma-separated origins (NEVER use *)
+CORS_ORIGINS=http://localhost:3000
+
+# LLM provider (optional)
+LLM_PROVIDER=dummy
+# OPENAI_API_KEY=

package/templates/stacks/rust-axum/.github/workflows/dare-ci.yml

@@ -0,0 +1,40 @@
+name: DARE CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  audit:
+    name: cargo audit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo install cargo-audit --locked
+      - run: cargo audit --deny warnings
+
+  lint:
+    name: clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy --workspace --all-targets -- -D warnings
+
+  test:
+    name: cargo test
+    runs-on: ubuntu-latest
+    env:
+      DATABASE_URL: postgres://user:pass@localhost:5432/test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo test --workspace

package/templates/stacks/rust-axum/Cargo.toml.tera

@@ -0,0 +1,53 @@
+[package]
+name = "{{ crateName }}"
+version = "0.1.0"
+edition = "2021"
+description = "DARE-shaped Axum API"
+license = "MIT"
+
+[dependencies]
+axum = { version = "0.7", features = ["macros", "ws"] }
+tokio = { version = "1", features = ["full"] }
+tower = "0.5"
+tower-http = { version = "0.6", features = ["cors", "trace"] }
+tower_governor = "0.4"
+
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+utoipa = { version = "5", features = ["axum_extras", "uuid"] }
+utoipa-axum = "0.1"
+utoipa-swagger-ui = { version = "8", features = ["axum"] }
+
+jsonwebtoken = "9"
+argon2 = "0.5"
+rand_core = { version = "0.6", features = ["std"] }
+
+sqlx = { version = "0.8", default-features = false, features = [
+    "runtime-tokio",
+    "postgres",
+    "macros",
+    "uuid",
+    "chrono",
+    "migrate",
+] }
+
+uuid = { version = "1", features = ["v4", "serde"] }
+chrono = { version = "0.4", features = ["serde"] }
+
+dotenvy = "0.15"
+thiserror = "1"
+anyhow = "1"
+
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+reqwest = { version = "0.12", features = ["json", "rustls-tls"], default-features = false }
+async-trait = "0.1"
+
+[dev-dependencies]
+tokio-test = "0.4"
+
+[[bin]]
+name = "{{ crateName }}"
+path = "src/main.rs"

package/templates/stacks/rust-axum/README.md.tera

@@ -0,0 +1,37 @@
+# {{ projectName }}
+
+DARE-shaped Rust API on Axum 0.7. Layered Design (Handler → Service → Repository → Model).
+
+## Setup
+
+```bash
+cp .env.example .env
+docker compose up -d postgres
+cargo install sqlx-cli --no-default-features --features postgres
+sqlx database create
+sqlx migrate run
+cargo run
+```
+
+## Endpoints
+
+- `POST /auth/login` — exchange email/password for JWT
+- `GET /auth/me` — current user (Bearer JWT)
+- `GET /users` — list users (paginated)
+- `POST /users` — create user (admin only)
+- `GET /ws` — WebSocket echo demo
+- `GET /openapi.json` — OpenAPI 3.x surface
+- `GET /swagger-ui` — Swagger UI
+
+## Commands
+
+- `cargo run` — dev server (port 8000)
+- `cargo test --workspace` — tests
+- `cargo clippy -- -D warnings` — lint
+- `cargo audit` — dependency audit
+- `sqlx migrate add <name>` — new migration
+- `sqlx migrate run` — apply migrations
+
+## DARE Method
+
+See `.dare/skills.yml` for installed skills, `llms.txt` for agent context.

package/templates/stacks/rust-axum/gitignore

@@ -0,0 +1,5 @@
+/target
+.env
+.env.local
+*.log
+.DS_Store

package/templates/stacks/rust-axum/llms.txt.tera

@@ -0,0 +1,54 @@
+# {{ projectName }}
+
+DARE-shaped Rust API on Axum 0.7. Layered Design: Handler → Service → Repository → Model.
+
+## Setup
+
+```bash
+cp .env.example .env
+docker compose up -d postgres
+cargo install sqlx-cli --no-default-features --features postgres
+sqlx database create
+sqlx migrate run
+cargo run
+```
+
+## Commands
+
+- `cargo run` — dev server (port 8000)
+- `cargo test --workspace` — tests
+- `cargo clippy -- -D warnings` — lint (warnings are errors)
+- `cargo audit` — RustSec advisory audit
+- `sqlx migrate add <name>` — new migration
+- `sqlx migrate run` — apply migrations
+
+## Endpoints
+
+| Method | Path | Auth | Description |
+|---|---|---|---|
+| POST | `/auth/login` | none | Exchange email+password for JWT |
+| GET | `/auth/me` | Bearer | Current user info |
+| GET | `/users` | Bearer | List users (query: page, limit) |
+| POST | `/users` | Bearer (admin) | Create user |
+| GET | `/ws` | upgrade | WebSocket echo example |
+| GET | `/openapi.json` | none | OpenAPI 3.x document (utoipa-generated at runtime) |
+| GET | `/swagger-ui` | none | Swagger UI |
+
+## Layered Design
+
+- `src/handlers/` — Axum extractors and route handlers
+- `src/services/` — business logic
+- `src/repositories/` — sqlx queries
+- `src/models/` — domain structs (FromRow / Serialize)
+- `src/middleware/` — auth + rate limit
+- `src/llm/` — provider abstraction
+
+Handlers never call sqlx directly — they go through services → repositories.
+
+## Env vars
+
+See `.env.example`. Required: `DATABASE_URL`, `JWT_SECRET`.
+
+## DARE skills
+
+See `.dare/skills.yml`.

package/templates/stacks/rust-axum/migrations/0001_create_users.sql

@@ -0,0 +1,13 @@
+-- 0001 — users table
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+CREATE TABLE IF NOT EXISTS users (
+    id          UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    email       VARCHAR(254) NOT NULL UNIQUE,
+    password    VARCHAR(255) NOT NULL,
+    role        VARCHAR(16) NOT NULL DEFAULT 'USER',
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS ix_users_email ON users (email);

package/templates/stacks/rust-axum/openapi.json.tera

@@ -0,0 +1,46 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "{{ projectName }}",
+    "version": "0.1.0",
+    "description": "DARE-shaped Rust/Axum API. Runtime spec served at /openapi.json by utoipa."
+  },
+  "paths": {
+    "/auth/login": {
+      "post": {
+        "summary": "Exchange email+password for JWT",
+        "responses": { "200": { "description": "JWT issued" }, "401": { "description": "Invalid credentials" } }
+      }
+    },
+    "/auth/me": {
+      "get": {
+        "summary": "Current user",
+        "security": [{ "bearer": [] }],
+        "responses": { "200": { "description": "User" }, "401": { "description": "Unauthorized" } }
+      }
+    },
+    "/users": {
+      "get": {
+        "summary": "List users",
+        "security": [{ "bearer": [] }],
+        "responses": { "200": { "description": "Page of users" } }
+      },
+      "post": {
+        "summary": "Create user (admin)",
+        "security": [{ "bearer": [] }],
+        "responses": { "201": { "description": "Created" }, "403": { "description": "Forbidden" } }
+      }
+    },
+    "/ws": {
+      "get": {
+        "summary": "WebSocket echo upgrade",
+        "responses": { "101": { "description": "Switching Protocols" } }
+      }
+    }
+  },
+  "components": {
+    "securitySchemes": {
+      "bearer": { "type": "http", "scheme": "bearer", "bearerFormat": "JWT" }
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+//! Runtime configuration read from environment.
+use std::env;
+
+use tower_http::cors::AllowOrigin;
+
+#[derive(Clone, Debug)]
+pub struct Config {
+    pub app_port: u16,
+    pub database_url: String,
+    pub jwt_secret: String,
+    pub jwt_expires_secs: i64,
+    pub rate_limit_per_sec: u64,
+    pub rate_limit_burst: u32,
+    pub cors_origins: Vec<String>,
+    pub llm_provider: String,
+}
+
+impl Config {
+    pub fn from_env() -> anyhow::Result<Self> {
+        Ok(Self {
+            app_port: env::var("APP_PORT").ok().and_then(|s| s.parse().ok()).unwrap_or(8000),
+            database_url: env::var("DATABASE_URL")?,
+            jwt_secret: env::var("JWT_SECRET").unwrap_or_else(|_| "replace-me-in-prod".into()),
+            jwt_expires_secs: env::var("JWT_EXPIRES_SECS").ok().and_then(|s| s.parse().ok()).unwrap_or(900),
+            rate_limit_per_sec: env::var("RATE_LIMIT_PER_SEC").ok().and_then(|s| s.parse().ok()).unwrap_or(10),
+            rate_limit_burst: env::var("RATE_LIMIT_BURST").ok().and_then(|s| s.parse().ok()).unwrap_or(20),
+            cors_origins: env::var("CORS_ORIGINS")
+                .unwrap_or_else(|_| "http://localhost:3000".into())
+                .split(',')
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+                .collect(),
+            llm_provider: env::var("LLM_PROVIDER").unwrap_or_else(|_| "dummy".into()),
+        })
+    }
+
+    pub fn cors_layer_origins(&self) -> AllowOrigin {
+        let parsed: Vec<axum::http::HeaderValue> = self
+            .cors_origins
+            .iter()
+            .filter_map(|o| o.parse().ok())
+            .collect();
+        AllowOrigin::list(parsed)
+    }
+}