@dewtech/dare-cli 3.0.0 → 3.1.0

package/templates/stacks/ruby-rails-8/app/models/user.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — User domain model
+# Convention (ADR-05): models are lean data objects — no callbacks, no fat model
+# Business logic lives in app/services/; data access in app/repositories/
+
+class User < ApplicationRecord
+  # ── Validations ─────────────────────────────────────────────────────────
+  validates :email, presence: true,
+                    uniqueness: { case_sensitive: false },
+                    format: { with: URI::MailTo::EMAIL_REGEXP }
+  validates :name,  presence: true, length: { minimum: 2, maximum: 100 }
+
+  # ── Scopes ───────────────────────────────────────────────────────────────
+  scope :active, -> { where(active: true) }
+
+  # ── DARE: NO callbacks, NO fat model logic ───────────────────────────────
+  # Use Services for: password hashing, welcome emails, event publishing, etc.
+  # Use Repositories for: queries, bulk updates, custom SQL
+  #
+  # WRONG (fat model):
+  #   before_create :send_welcome_email
+  #   after_save    :publish_event
+  #
+  # RIGHT (service):
+  #   Services::CreateUserService.new(...).execute(params)
+
+  # ── Simple domain helpers (pure data concerns only) ──────────────────────
+  def display_name
+    name.presence || email.split("@").first
+  end
+
+  def can_view?(user_id)
+    id == user_id.to_i || admin?
+  end
+end

package/templates/stacks/ruby-rails-8/app/presenters/user_presenter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — UserPresenter
+# Convention (ADR-05): serialization concern isolated from model and controller
+# Returns plain Hash; handler renders JSON from it
+
+class UserPresenter
+  def initialize(user)
+    @user = user
+  end
+
+  # Full representation — used in show/create responses
+  def as_json(*)
+    {
+      id:         @user.id,
+      email:      @user.email,
+      name:       @user.name,
+      active:     @user.active?,
+      created_at: @user.created_at&.iso8601,
+      updated_at: @user.updated_at&.iso8601,
+    }
+  end
+
+  def to_json(*)
+    as_json.to_json
+  end
+
+  # Collection representation — used in index responses
+  # Wraps an array of presenters into a standard envelope
+  def self.collection(users, meta: {})
+    {
+      data: users.map { |u| new(u).as_json },
+      meta: {
+        count: users.size,
+        **meta
+      }
+    }
+  end
+
+  # Minimal summary representation (e.g. for nested resources)
+  def summary
+    {
+      id:    @user.id,
+      email: @user.email,
+      name:  @user.name
+    }
+  end
+end

package/templates/stacks/ruby-rails-8/app/repositories/document_repository.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — DocumentRepository (interface + ActiveRecord implementation)
+# Convention (ADR-05): data access is isolated here — services never call AR directly
+# This enables easy mocking in unit tests and future DB swaps
+
+module Repositories
+  class DocumentRepository
+    # ── Query ──────────────────────────────────────────────────────────────
+
+    def find(id)
+      Document.find_by(id: id)
+    end
+
+    def find!(id)
+      Document.find(id)
+    rescue ActiveRecord::RecordNotFound
+      raise ActiveRecord::RecordNotFound, "Document with id=#{id} was not found."
+    end
+
+    def all
+      Document.order(created_at: :desc)
+    end
+
+    def by_user(user_id)
+      Document.where(user_id: user_id).order(created_at: :desc)
+    end
+
+    # ── Persistence ────────────────────────────────────────────────────────
+
+    # Builds a new Document (not persisted).
+    def build(attrs = {})
+      Document.new(attrs)
+    end
+
+    # Persist (create or update). Raises ActiveRecord::RecordInvalid on failure.
+    def save!(document)
+      document.save!
+      document
+    end
+
+    # Update summary and timestamp after LLM processing.
+    def update_summary!(document, summary)
+      document.update!(summary: summary, summarized_at: Time.current)
+      document
+    end
+
+    def update!(document, attributes)
+      document.update!(attributes)
+      document
+    end
+
+    def destroy!(document)
+      document.destroy!
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/app/repositories/user_repository.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — UserRepository
+# Convention (ADR-05): data access is isolated here — services never call AR directly
+# This enables easy mocking in unit tests and future DB swaps
+
+module Repositories
+  class UserRepository
+    # ── Query ──────────────────────────────────────────────────────────────
+
+    def find(id)
+      User.find_by(id: id)
+    end
+
+    def find!(id)
+      User.find(id)
+    rescue ActiveRecord::RecordNotFound
+      raise ActiveRecord::RecordNotFound, "User with id=#{id} was not found."
+    end
+
+    def find_by_email(email)
+      User.find_by(email: email.downcase.strip)
+    end
+
+    def all_active
+      User.active.order(created_at: :desc)
+    end
+
+    def paginated(page: 1, per: 25)
+      User.active
+          .order(created_at: :desc)
+          .offset((page.to_i - 1) * per.to_i)
+          .limit(per.to_i)
+    end
+
+    def count
+      User.count
+    end
+
+    # ── Persistence ────────────────────────────────────────────────────────
+
+    # Builds a new User (not persisted). Let the service validate input first.
+    def build(attributes = {})
+      User.new(attributes)
+    end
+
+    # Persist (create or update). Raises ActiveRecord::RecordInvalid on failure.
+    def save!(user)
+      user.save!
+      user
+    end
+
+    # Persist without raising. Returns false on failure.
+    def save(user)
+      user.save
+    end
+
+    def update!(user, attributes)
+      user.update!(attributes)
+      user
+    end
+
+    def destroy!(user)
+      user.destroy!
+    end
+
+    # ── Bulk ───────────────────────────────────────────────────────────────
+
+    def deactivate_all_inactive(since:)
+      User.where("last_active_at < ?", since).update_all(active: false)
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/app/services/create_user_service.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — CreateUserService
+# Convention (ADR-01): one service per operation; injected dependencies for testability
+#
+# Usage:
+#   result = Services::CreateUserService.new(
+#     user_repository: Repositories::UserRepository.new,
+#     event_publisher: RealtimeService.instance
+#   ).execute(email: "user@example.com", name: "Alice")
+#
+# Returns: User (persisted)
+# Raises:  Services::CreateUserService::EmailTakenError
+#          ActiveRecord::RecordInvalid (validation failure)
+
+module Services
+  class CreateUserService
+    # ── Domain errors ──────────────────────────────────────────────────────
+    class EmailTakenError < StandardError
+      def initialize(email)
+        super("Email '#{email}' is already registered.")
+      end
+    end
+
+    # ── Constructor ────────────────────────────────────────────────────────
+    def initialize(user_repository:, event_publisher:)
+      @user_repository = user_repository
+      @event_publisher = event_publisher
+    end
+
+    # ── Main operation ─────────────────────────────────────────────────────
+    def execute(email:, name:, password: nil, **extra_attrs)
+      email = email.to_s.downcase.strip
+
+      # Guard: check for duplicate email
+      if @user_repository.find_by_email(email)
+        raise EmailTakenError, email
+      end
+
+      # Build and persist
+      user = @user_repository.build(
+        email:      email,
+        name:       name.to_s.strip,
+        active:     true,
+        **extra_attrs
+      )
+
+      # Hash password if provided (example using has_secure_password)
+      user.password = password if password.present?
+
+      @user_repository.save!(user)
+
+      # Publish real-time event
+      @event_publisher.publish(
+        type: "user.created",
+        data: {
+          user_id: user.id,
+          email:   user.email,
+          name:    user.name,
+          timestamp: Time.now.to_i
+        }
+      )
+
+      user
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/app/services/realtime_service.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — RealtimeService
+# Convention (ADR-03): centralized broadcaster — services call this, not channels directly
+# Singleton via .instance; injectable in tests via double
+#
+# Usage in a Service:
+#   RealtimeService.instance.publish(
+#     type: "user.created",
+#     data: { user_id: 42, email: "user@example.com" }
+#   )
+#
+# Frontend receives:
+#   { type: "user.created", data: { ... }, timestamp: 1234567890 }
+
+class RealtimeService
+  include Singleton
+
+  # ── Public API ────────────────────────────────────────────────────────────
+
+  # Broadcast to all subscribers of a channel stream.
+  # channel_class: e.g. UserUpdatesChannel
+  # target:        e.g. user.id  (matched against stream_for in the channel)
+  # payload:       Hash with :type and :data
+  def broadcast_to(channel_class, target, type:, data: {})
+    event = build_event(type: type, data: data)
+    channel_class.broadcast_to(target, event)
+  end
+
+  # Generic publish: broadcasts to `dare_updates:<user_id>` for all active users.
+  # Use for system-wide events.
+  def publish(type:, data: {}, user_id: nil)
+    event   = build_event(type: type, data: data)
+    stream  = user_id ? "dare_updates:#{user_id}" : "dare_updates:global"
+    ActionCable.server.broadcast(stream, event)
+  end
+
+  # Publish to a named stream directly (lower-level).
+  def broadcast_to_stream(stream_name, type:, data: {})
+    event = build_event(type: type, data: data)
+    ActionCable.server.broadcast(stream_name, event)
+  end
+
+  private
+
+  def build_event(type:, data: {})
+    {
+      type:      type,
+      data:      data,
+      timestamp: Time.now.to_i
+    }
+  end
+end

package/templates/stacks/ruby-rails-8/app/services/summarize_document_service.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — SummarizeDocumentService
+# Convention (ADR-01): single responsibility — load document, call LLM, persist summary, emit event
+#
+# Usage:
+#   result = Services::SummarizeDocumentService.new(
+#     document_repository: Repositories::DocumentRepository.new,
+#     llm_provider:        LLM::Providers::LLMProvider.instance,
+#     event_publisher:     RealtimeService.instance
+#   ).execute(document_id: "abc-123", user_id: 42)
+#
+# Returns: SummarizeDocumentService::Result (summary, document_id)
+# Raises:  Services::SummarizeDocumentService::DocumentNotFoundError
+#          Services::SummarizeDocumentService::SummarizationError
+
+module Services
+  class SummarizeDocumentService
+    # ── Domain errors ──────────────────────────────────────────────────────
+    DocumentNotFoundError = Class.new(StandardError)
+    SummarizationError    = Class.new(StandardError)
+
+    # ── Result ─────────────────────────────────────────────────────────────
+    Result = Struct.new(:summary, :document_id, keyword_init: true)
+
+    # ── Constructor ────────────────────────────────────────────────────────
+    def initialize(document_repository:, llm_provider:, event_publisher:)
+      @document_repository = document_repository
+      @llm_provider        = llm_provider
+      @event_publisher     = event_publisher
+    end
+
+    # ── Main operation ─────────────────────────────────────────────────────
+    def execute(document_id:, user_id:)
+      doc = @document_repository.find(document_id)
+      raise DocumentNotFoundError, "Document #{document_id} not found" if doc.nil?
+
+      prompt  = LLM::Prompts::PromptLoader.load("summarize_v1", content: doc.content, language: "pt-BR")
+      summary = @llm_provider.complete(model: "gpt-4o-mini", prompt: prompt)
+
+      raise SummarizationError, "LLM returned empty summary" if summary.blank?
+
+      @document_repository.update_summary!(doc, summary)
+
+      @event_publisher.publish(
+        type: "document.summarized",
+        data: {
+          document_id:    document_id,
+          user_id:        user_id,
+          summary_length: summary.length
+        }
+      )
+
+      Result.new(summary: summary, document_id: document_id)
+    end
+  end
+end

package/templates/stacks/ruby-rails-8/config/dare.yml

@@ -0,0 +1,42 @@
+# DARE v3.0 — Application configuration
+# Access in Ruby via: Rails.configuration.dare
+# Environment-specific settings override the "default" block.
+
+default: &default
+  llm:
+    provider: dummy          # dummy | openai | local_llama
+    model: gpt-4o
+    # api_key: set via OPENAI_API_KEY env var (never in source)
+
+  rate_limit:
+    rpm: 100                 # requests per minute per IP (public API)
+    auth_rpm: 10             # requests per minute per IP (auth endpoints)
+    llm_rpm: 20              # requests per minute per user (LLM endpoints)
+
+  openapi:
+    enabled: true
+    output_path: public/openapi.json
+    title: "<%= app_name %> API"
+    version: "1.0.0"
+    description: "REST API built with Rails 8 + DARE v3.0"
+
+  realtime:
+    backend: action_cable    # action_cable | sucker_punch
+    redis_url: <%= ENV.fetch('REDIS_URL', 'redis://localhost:6379/0') %>
+
+development:
+  <<: *default
+  llm:
+    provider: dummy
+
+test:
+  <<: *default
+  llm:
+    provider: dummy
+  rate_limit:
+    rpm: 10000               # effectively unlimited in tests
+
+production:
+  <<: *default
+  llm:
+    provider: openai         # set OPENAI_API_KEY in environment

package/templates/stacks/ruby-rails-8/config/initializers/dare.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — Central configuration initializer
+# All DARE runtime settings are loaded from config/dare.yml
+# Access via: Rails.configuration.dare
+
+dare_config_path = Rails.root.join("config", "dare.yml")
+
+if dare_config_path.exist?
+  raw = YAML.safe_load_file(dare_config_path, symbolize_names: false)
+  env_config = raw.dig(Rails.env) || raw["default"] || {}
+
+  Rails.configuration.dare = OpenStruct.new(
+    llm_provider:   env_config.dig("llm", "provider") || "dummy",
+    llm_model:      env_config.dig("llm", "model")    || "gpt-4o",
+    llm_api_key:    ENV.fetch("OPENAI_API_KEY", nil),
+    redis_url:      ENV.fetch("REDIS_URL", "redis://localhost:6379/0"),
+    rate_limit_rpm: env_config.dig("rate_limit", "rpm") || 100,
+    metrics_path:   Rails.root.join("tmp", "dare_metrics.json")
+  )
+else
+  Rails.logger.warn "[DARE] config/dare.yml not found — using defaults"
+  Rails.configuration.dare = OpenStruct.new(
+    llm_provider:   "dummy",
+    llm_model:      "gpt-4o",
+    llm_api_key:    ENV.fetch("OPENAI_API_KEY", nil),
+    redis_url:      ENV.fetch("REDIS_URL", "redis://localhost:6379/0"),
+    rate_limit_rpm: 100,
+    metrics_path:   Rails.root.join("tmp", "dare_metrics.json")
+  )
+end

package/templates/stacks/ruby-rails-8/config/initializers/rack_attack.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — Rack::Attack configuration
+# Satisfies metric M-04: 100% of public endpoints have rate limit configured
+#
+# D-006 (RFC 7807): throttle responses use Problem Details format
+
+class Rack::Attack
+  # ── Safelist ───────────────────────────────────────────────────────────────
+  # Always allow localhost in development
+  safelist("allow-localhost") do |req|
+    req.ip == "127.0.0.1" || req.ip == "::1" if Rails.env.development?
+  end
+
+  # ── Public API throttle ───────────────────────────────────────────────────
+  # M-04: All public endpoints limited to 100 req/min per IP
+  throttle("public-api/ip", limit: 100, period: 1.minute) do |req|
+    req.ip if req.path.start_with?("/api/")
+  end
+
+  # ── Auth endpoints throttle ───────────────────────────────────────────────
+  # 10 req/min per IP for sensitive auth endpoints
+  throttle("auth/ip", limit: 10, period: 1.minute) do |req|
+    req.ip if req.path =~ %r{\A/api/(auth|sessions|passwords)}
+  end
+
+  # ── LLM endpoints throttle ───────────────────────────────────────────────
+  # 20 req/min per authenticated user for LLM-heavy endpoints
+  throttle("llm/user", limit: 20, period: 1.minute) do |req|
+    req.env["HTTP_X_USER_ID"] if req.path.start_with?("/api/") && req.env["HTTP_X_USER_ID"]
+  end
+
+  # ── Response — RFC 7807 Problem Details ───────────────────────────────────
+  self.throttled_responder = lambda do |env|
+    match_data = env["rack.attack.match_data"]
+    now        = match_data[:epoch_time]
+    retry_at   = now + (match_data[:period] - now % match_data[:period])
+
+    headers = {
+      "Content-Type"  => "application/problem+json",
+      "Retry-After"   => (retry_at - now).to_s,
+      "X-RateLimit-Limit"     => match_data[:limit].to_s,
+      "X-RateLimit-Remaining" => "0",
+      "X-RateLimit-Reset"     => retry_at.to_s,
+    }
+
+    body = {
+      type:     "https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429",
+      title:    "Too Many Requests",
+      status:   429,
+      detail:   "Rate limit exceeded. Please retry after #{retry_at - now} seconds.",
+      instance: env["PATH_INFO"],
+    }.to_json
+
+    [429, headers, [body]]
+  end
+end
+
+# Use Redis for distributed rate limiting (multi-server setups)
+if defined?(Redis) && ENV["REDIS_URL"]
+  Rack::Attack.cache.store = ActiveSupport::Cache::RedisCacheStore.new(
+    url: ENV["REDIS_URL"]
+  )
+end

package/templates/stacks/ruby-rails-8/config/initializers/rswag_api.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# DARE v3.0 — rswag API configuration
+# Satisfies metric M-02: 100% of endpoints have OpenAPI documentation
+
+Rswag::Api.configure do |c|
+  # Path to the generated openapi.json spec file
+  c.openapi_root = Rails.root.join("public").to_s
+
+  # Authorize all endpoints in Swagger UI with Bearer token by default
+  c.swagger_filter = lambda { |swagger, env| swagger }
+end