@dewtech/dare-cli 2.17.0 → 3.1.0

package/templates/stacks/ruby-rails-8/spec/channels/user_updates_channel_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — UserUpdatesChannel spec
+# Convention (ADR-06): tests auth and subscription behavior
+require "rails_helper"
+
+RSpec.describe UserUpdatesChannel, type: :channel do
+  let(:user) { create(:user) }
+
+  describe "#subscribed" do
+    context "when user is authenticated and subscribing to their own updates" do
+      before do
+        stub_connection current_user: user
+      end
+
+      it "subscribes successfully" do
+        subscribe user_id: user.id
+
+        expect(subscription).to be_confirmed
+      end
+
+      it "streams for the user" do
+        subscribe user_id: user.id
+
+        expect(streams).to include("user_updates:#{user.id}")
+      end
+    end
+
+    context "when user tries to subscribe to another user's updates without permission" do
+      let(:other_user) { create(:user) }
+
+      before do
+        stub_connection current_user: user
+        allow(user).to receive(:can_view?).with(other_user.id).and_return(false)
+      end
+
+      it "rejects the subscription" do
+        subscribe user_id: other_user.id
+
+        expect(subscription).to be_rejected
+      end
+    end
+
+    context "when user is not authenticated" do
+      before do
+        stub_connection current_user: nil
+      end
+
+      it "rejects the subscription" do
+        subscribe user_id: user.id
+
+        expect(subscription).to be_rejected
+      end
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/factories/users.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — FactoryBot factories
+# Convention: no fixtures YAML; FactoryBot only
+
+FactoryBot.define do
+  factory :user do
+    sequence(:email) { |n| "user#{n}@example.com" }
+    name             { Faker::Name.name }
+    active           { true }
+
+    # Trait: admin user
+    trait :admin do
+      admin { true }
+    end
+
+    # Trait: inactive user
+    trait :inactive do
+      active { false }
+    end
+
+    # Trait: with all optional fields
+    trait :complete do
+      last_active_at { 1.day.ago }
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/spec/handlers/users_handler_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — UsersHandler spec
+# Convention (ADR-06): request specs test HTTP contract
+require "rails_helper"
+
+RSpec.describe "Users API", type: :request do
+  let(:user)         { create(:user) }
+  let(:valid_params) { { user: { email: "bob@example.com", name: "Bob" } } }
+
+  describe "GET /api/users/:id" do
+    context "when user exists" do
+      it "returns 200 with user JSON" do
+        get "/api/users/#{user.id}"
+
+        expect(response).to have_http_status(:ok)
+        json = JSON.parse(response.body)
+        expect(json["email"]).to eq user.email
+      end
+    end
+
+    context "when user does not exist" do
+      it "returns 404 Problem Details" do
+        get "/api/users/99999"
+
+        expect(response).to have_http_status(:not_found)
+        json = JSON.parse(response.body)
+        expect(json["status"]).to eq 404
+        expect(json["title"]).to be_present
+        expect(response.content_type).to include("application/problem+json")
+      end
+    end
+  end
+
+  describe "POST /api/users" do
+    context "with valid params" do
+      it "returns 201 Created" do
+        post "/api/users", params: valid_params, as: :json
+
+        expect(response).to have_http_status(:created)
+        json = JSON.parse(response.body)
+        expect(json["email"]).to eq "bob@example.com"
+      end
+    end
+
+    context "with duplicate email" do
+      before { create(:user, email: "bob@example.com") }
+
+      it "returns 409 Conflict with Problem Details" do
+        post "/api/users", params: valid_params, as: :json
+
+        expect(response).to have_http_status(:conflict)
+        json = JSON.parse(response.body)
+        expect(json["status"]).to eq 409
+        expect(response.content_type).to include("application/problem+json")
+      end
+    end
+
+    context "with missing required params" do
+      it "returns 400 Bad Request" do
+        post "/api/users", params: { user: {} }, as: :json
+
+        expect(response).to have_http_status(:bad_request)
+      end
+    end
+  end
+
+  describe "PATCH /api/users/:id" do
+    it "returns 200 with updated user" do
+      patch "/api/users/#{user.id}",
+            params: { user: { name: "Updated Name" } },
+            as:     :json,
+            headers: { "Authorization" => "Bearer test-token" }
+
+      # Note: authentication stub needed — wire up in test support
+      expect(response).not_to have_http_status(:internal_server_error)
+    end
+  end
+
+  describe "DELETE /api/users/:id" do
+    it "returns 204 No Content" do
+      delete "/api/users/#{user.id}",
+             headers: { "Authorization" => "Bearer test-token" }
+
+      expect(response).not_to have_http_status(:internal_server_error)
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — RSpec rails_helper
+
+ENV["RAILS_ENV"] ||= "test"
+require_relative "../config/environment"
+require "rspec/rails"
+
+# Require support files
+Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
+
+# Prevent database truncation if the environment is production
+abort("The Rails environment is running in production mode!") if Rails.env.production?
+
+RSpec.configure do |config|
+  config.fixture_paths = ["#{::Rails.root}/spec/fixtures"]
+  config.use_transactional_fixtures = true
+  config.infer_spec_type_from_file_location!
+  config.filter_rails_from_backtrace!
+
+  # FactoryBot
+  config.include FactoryBot::Syntax::Methods
+
+  # Shoulda Matchers
+  Shoulda::Matchers.configure do |shoulda|
+    shoulda.integrate do |with|
+      with.test_framework :rspec
+      with.library        :rails
+    end
+  end
+end

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