better_service 2.0.0 → 2.1.0

data/lib/generators/serviceable/show_generator.rb

@@ -9,6 +9,9 @@ module Serviceable
 
       desc "Generate a Show service for displaying a single resource"
 
+      class_option :base_class, type: :string, default: nil,
+                   desc: "Custom base class to inherit from (e.g., Articles::BaseService)"
+
       def create_service_file
         template "show_service.rb.tt", File.join("app/services", class_path, "#{file_name}/show_service.rb")
       end
@@ -22,6 +25,14 @@ module Serviceable
       def service_class_name
         "#{class_name}::ShowService"
       end
+
+      def parent_class
+        options[:base_class] || "BetterService::Services::Base"
+      end
+
+      def using_base_service?
+        options[:base_class].present?
+      end
     end
   end
 end

data/lib/generators/serviceable/templates/action_service.rb.tt

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 <% module_namespacing do -%>
-class <%= class_name %>::<%= action_name.camelize %>Service < BetterService::Services::ActionService
-  action_name :<%= action_name %>
+class <%= class_name %>::<%= action_name.camelize %>Service < <%= parent_class %>
+  # Action name for metadata
+  performed_action :<%= action_name %>
 
   # Schema for validating params
   schema do
@@ -23,7 +24,11 @@ class <%= class_name %>::<%= action_name.camelize %>Service < BetterService::Ser
 
   # Phase 1: Search - Load the resource
   search_with do
+<% if using_base_service? -%>
+    { resource: <%= singular_table_name %>_repository.find(params[:id]) }
+<% else -%>
     { resource: user.<%= plural_table_name %>.find(params[:id]) }
+<% end -%>
   end
 
   # Phase 2: Process - Perform the action
@@ -36,7 +41,7 @@ class <%= class_name %>::<%= action_name.camelize %>Service < BetterService::Ser
 
   # Phase 4: Respond - Format response (optional override)
   respond_with do |data|
-    success_result("<%= human_name %> <%= action_name %> successfully", data)
+    success_result(message("<%= action_name %>.success"), data)
   end
 end
 <% end -%>

data/lib/generators/serviceable/templates/base_locale.en.yml.tt

@@ -0,0 +1,53 @@
+en:
+  <%= file_name %>:
+    services:
+      # Index service messages
+      index:
+        success: "<%= human_name.pluralize %> loaded successfully"
+        error: "Error loading <%= human_name.downcase.pluralize %>"
+        empty: "No <%= human_name.downcase.pluralize %> found"
+
+      # Show service messages
+      show:
+        success: "<%= human_name %> loaded successfully"
+        error: "Error loading <%= human_name.downcase %>"
+        not_found: "<%= human_name %> not found"
+
+      # Create service messages
+      create:
+        success: "<%= human_name %> created successfully"
+        error: "Error creating <%= human_name.downcase %>"
+        validation_failed: "Could not create <%= human_name.downcase %> due to validation errors"
+
+      # Update service messages
+      update:
+        success: "<%= human_name %> updated successfully"
+        error: "Error updating <%= human_name.downcase %>"
+        validation_failed: "Could not update <%= human_name.downcase %> due to validation errors"
+        not_found: "<%= human_name %> not found"
+
+      # Destroy service messages
+      destroy:
+        success: "<%= human_name %> deleted successfully"
+        error: "Error deleting <%= human_name.downcase %>"
+        not_found: "<%= human_name %> not found"
+        cannot_destroy: "Cannot delete this <%= human_name.downcase %>"
+
+      # Common messages (shared across services)
+      common:
+        success: "Operation completed successfully"
+        error: "An error occurred"
+        not_found: "<%= human_name %> not found"
+        not_authorized: "You are not authorized to perform this action"
+        invalid_params: "Invalid parameters provided"
+        already_exists: "<%= human_name %> already exists"
+
+      # Add custom action messages here:
+      # publish:
+      #   success: "<%= human_name %> published successfully"
+      #   error: "Error publishing <%= human_name.downcase %>"
+      #   already_published: "<%= human_name %> is already published"
+      #
+      # archive:
+      #   success: "<%= human_name %> archived successfully"
+      #   error: "Error archiving <%= human_name.downcase %>"

data/lib/generators/serviceable/templates/base_service.rb.tt

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+# BaseService for <%= class_name %> resource operations.
+#
+# Provides centralized configuration for all <%= class_name %> services:
+# - Repository access via RepositoryAware concern
+# - I18n messages namespace
+# - Cache invalidation contexts
+# - Presenter configuration
+#
+# All <%= class_name %> services should inherit from this class:
+#   class <%= class_name %>::IndexService < <%= class_name %>::BaseService
+#   class <%= class_name %>::CreateService < <%= class_name %>::BaseService
+#
+# @example Usage
+#   class <%= class_name %>::IndexService < <%= class_name %>::BaseService
+#     schema do
+#       optional(:page).filled(:integer, gteq?: 1)
+#     end
+#
+#     search_with do
+#       { items: <%= singular_table_name %>_repository.all.to_a }
+#     end
+#   end
+#
+class <%= class_name %>::BaseService < BetterService::Services::Base
+  include BetterService::Concerns::Serviceable::RepositoryAware
+
+  # I18n messages namespace - messages are loaded from:
+  # config/locales/<%= file_name %>_services.en.yml
+  messages_namespace :<%= file_name %>
+
+  # Cache contexts for automatic invalidation
+  # Create/Update/Destroy services will invalidate these contexts
+  cache_contexts [:<%= plural_table_name %>]
+
+<% unless options[:skip_presenter] -%>
+  # Presenter for transforming data in responses
+  # Generate with: rails generate better_service:presenter <%= class_name %>
+  # presenter <%= class_name %>Presenter
+  # presenter_options do
+  #   { current_user: user }
+  # end
+
+<% end -%>
+<% unless options[:skip_repository] -%>
+  # Repository declaration - creates <%= singular_table_name %>_repository method
+  repository :<%= singular_table_name %>
+
+  # Add more repositories as needed:
+  # repository :user
+  # repository :category, class_name: "Categories::CategoryRepository"
+
+<% end -%>
+  private
+
+  # Override to provide default error message for this resource
+  def default_error_message
+    message("common.error")
+  end
+
+  # Override to provide default success message for this resource
+  def default_success_message
+    message("common.success")
+  end
+
+  # Add shared helper methods for all <%= class_name %> services here:
+  #
+  # def find_<%= singular_table_name %>(id)
+  #   <%= singular_table_name %>_repository.find(id)
+  # end
+  #
+  # def <%= singular_table_name %>_authorized?(record)
+  #   record.user_id == user.id
+  # end
+end
+<% end -%>

data/lib/generators/serviceable/templates/base_service_test.rb.tt

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>::BaseServiceTest < ActiveSupport::TestCase
+  def setup
+    @user = users(:one) # Adjust fixture name as needed
+  end
+
+  # Test that the base service cannot be called directly
+  # (it requires subclass implementation)
+  test "base service requires schema definition" do
+    assert_raises(BetterService::Errors::Configuration::SchemaRequiredError) do
+      <%= class_name %>::BaseService.new(@user, params: {})
+    end
+  end
+
+  test "messages_namespace is configured" do
+    assert_equal :<%= file_name %>, <%= class_name %>::BaseService._messages_namespace
+  end
+
+  test "cache_contexts is configured" do
+    assert_includes <%= class_name %>::BaseService._cache_contexts, :<%= plural_table_name %>
+  end
+<% unless options[:skip_repository] -%>
+
+  # Repository tests
+  # Note: These tests verify the repository declaration works
+  # Actual repository functionality is tested in repository_test.rb
+
+  test "repository is accessible via method" do
+    # Create a concrete subclass to test repository access
+    test_service_class = Class.new(<%= class_name %>::BaseService) do
+      schema { optional(:id).filled }
+
+      def test_repository_access
+        <%= singular_table_name %>_repository
+      end
+    end
+
+    service = test_service_class.new(@user, params: {})
+    repo = service.send(:test_repository_access)
+
+    assert_instance_of <%= class_name %>Repository, repo
+  end
+
+  test "repository is memoized" do
+    test_service_class = Class.new(<%= class_name %>::BaseService) do
+      schema { optional(:id).filled }
+
+      def test_repository_memoization
+        [<%= singular_table_name %>_repository, <%= singular_table_name %>_repository]
+      end
+    end
+
+    service = test_service_class.new(@user, params: {})
+    repos = service.send(:test_repository_memoization)
+
+    assert_same repos[0], repos[1], "Repository should be memoized"
+  end
+<% end -%>
+end
+<% end -%>

data/lib/generators/serviceable/templates/create_service.rb.tt

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 <% module_namespacing do -%>
-class <%= class_name %>::CreateService < BetterService::Services::CreateService
-  # Database transactions are ENABLED by default for create operations
-  # The process block will automatically run inside a transaction
-  # To disable: with_transaction false
+class <%= class_name %>::CreateService < <%= parent_class %>
+  # Action name for metadata
+  performed_action :created
+
+  # Enable transaction wrapping
+  with_transaction true
 
   # Schema for validating params
   schema do
@@ -20,24 +22,33 @@ class <%= class_name %>::CreateService < BetterService::Services::CreateService
   end
 
   # Phase 2: Process - Create the resource (runs in transaction)
+  # Uses save (not save!) to allow graceful validation handling
   process_with do |data|
-    <%= file_name %> = user.<%= plural_table_name %>.create!(params)
-    { resource: <%= file_name %> }
+<% if using_base_service? -%>
+    record = <%= singular_table_name %>_repository.build(params)
+
+    if record.save
+      { object: record }
+    else
+      failure_for(record)
+    end
+<% else -%>
+    <%= file_name %> = user.<%= plural_table_name %>.build(params)
+
+    if <%= file_name %>.save
+      { object: <%= file_name %> }
+    else
+      failure_for(<%= file_name %>)
+    end
+<% end -%>
   end
 
-  # Phase 4: Respond - Format response (optional override)
-  # Uses I18n message helper with fallback to default messages
-  #
-  # To customize messages, create config/locales/<%= plural_table_name %>_services.en.yml:
-  #   en:
-  #     <%= plural_table_name %>:
-  #       services:
-  #         create:
-  #           success: "<%= human_name %> created successfully!"
-  #
-  # Then configure namespace: messages_namespace :<%= plural_table_name %>
+  # Phase 4: Respond - Format response
   respond_with do |data|
-    success_result(message("create.success"), data)
+    # Pass through failure responses
+    return data if data[:success] == false
+
+    success_for(data[:object], message("create.success"))
   end
 end
 <% end -%>

data/lib/generators/serviceable/templates/destroy_service.rb.tt

@@ -1,50 +1,37 @@
 # frozen_string_literal: true
 
 <% module_namespacing do -%>
-class <%= class_name %>::DestroyService < BetterService::Services::DestroyService
-  # Database transactions are ENABLED by default for destroy operations
-  # The process block will automatically run inside a transaction
-  # To disable: with_transaction false
+class <%= class_name %>::DestroyService < <%= parent_class %>
+  # Action name for metadata
+  performed_action :destroyed
+
+  # Enable transaction wrapping
+  with_transaction true
 
   # Schema for validating params
   schema do
     required(:id).filled
   end
 
-  # Authorization (optional) - Runs BEFORE search phase
-  # Uncomment and customize for your needs:
-  #
-  # authorize_with do
-  #   # Example: Check ownership or admin role
-  #   <%= file_name %> = <%= class_name %>.find(params[:id])
-  #   user.admin? || <%= file_name %>.user_id == user.id
-  # end
-
   # Phase 1: Search - Load the resource
   search_with do
-    { resource: user.<%= plural_table_name %>.find(params[:id]) }
+<% if using_base_service? -%>
+    { object: <%= singular_table_name %>_repository.find(params[:id]) }
+<% else -%>
+    { object: user.<%= plural_table_name %>.find(params[:id]) }
+<% end -%>
   end
 
   # Phase 2: Process - Delete the resource (runs in transaction)
   process_with do |data|
-    <%= file_name %> = data[:resource]
-    <%= file_name %>.destroy!
-    { resource: <%= file_name %> }
+    record = data[:object]
+    record.destroy!
+    { object: record }
   end
 
-  # Phase 4: Respond - Format response (optional override)
-  # Uses I18n message helper with fallback to default messages
-  #
-  # To customize messages, create config/locales/<%= plural_table_name %>_services.en.yml:
-  #   en:
-  #     <%= plural_table_name %>:
-  #       services:
-  #         destroy:
-  #           success: "<%= human_name %> deleted successfully!"
-  #
-  # Then configure namespace: messages_namespace :<%= plural_table_name %>
+  # Phase 4: Respond - Format response
   respond_with do |data|
-    success_result(message("destroy.success"), data)
+    success_for(data[:object], message("destroy.success"))
   end
 end
 <% end -%>

data/lib/generators/serviceable/templates/index_service.rb.tt

@@ -1,14 +1,9 @@
 # frozen_string_literal: true
 
 <% module_namespacing do -%>
-class <%= class_name %>::IndexService < BetterService::Services::IndexService
-  # Optional: Use a presenter to format response data
-  # Generate with: rails generate better_service:presenter <%= class_name %>
-  #
-  # presenter <%= class_name %>Presenter
-  # presenter_options do
-  #   { current_user: user }
-  # end
+class <%= class_name %>::IndexService < <%= parent_class %>
+  # Action name for metadata
+  performed_action :listed
 
   # Schema for validating params
   schema do
@@ -19,21 +14,29 @@ class <%= class_name %>::IndexService < BetterService::Services::IndexService
 
   # Phase 1: Search - Load raw data
   search_with do
+<% if using_base_service? -%>
+    # Use repository for data access
+    predicates = {}
+    predicates[:search] = params[:search] if params[:search].present?
+
+    { object: <%= singular_table_name %>_repository.search(predicates, page: params[:page] || 1, per_page: params[:per_page] || 25).to_a }
+<% else -%>
     <%= plural_table_name %> = user.<%= plural_table_name %>
     <%= plural_table_name %> = <%= plural_table_name %>.where("title LIKE ?", "%#{params[:search]}%") if params[:search].present?
     # Add pagination if needed (e.g., with Kaminari or Pagy)
     # <%= plural_table_name %> = <%= plural_table_name %>.page(params[:page]).per(params[:per_page] || 25)
 
-    { items: <%= plural_table_name %>.to_a }
+    { object: <%= plural_table_name %>.to_a }
+<% end -%>
   end
 
   # Phase 2: Process - Transform and aggregate data
   process_with do |data|
     {
-      items: data[:items],
+      object: data[:object],
       metadata: {
         stats: {
-          total: data[:items].count
+          total: data[:object].count
         },
         pagination: {
           page: params[:page] || 1,
@@ -43,30 +46,9 @@ class <%= class_name %>::IndexService < BetterService::Services::IndexService
     }
   end
 
-  # Phase 4: Respond - Format response (optional override)
-  # Uses I18n message helper with fallback to default messages
-  #
-  # To customize messages, create config/locales/<%= plural_table_name %>_services.en.yml:
-  #   en:
-  #     <%= plural_table_name %>:
-  #       services:
-  #         index:
-  #           success: "<%= plural_table_name.titleize %> loaded successfully!"
-  #
-  # Then configure namespace: messages_namespace :<%= plural_table_name %>
+  # Phase 4: Respond - Format response
   respond_with do |data|
-    success_result(message("index.success"), data)
+    success_for(data[:object], message("index.success")).merge(metadata: data[:metadata])
   end
-
-  # Phase 5: Viewer - UI configuration (optional)
-  # viewer do |processed, transformed, result|
-  #   {
-  #     page_title: "<%= plural_table_name.titleize %>",
-  #     breadcrumbs: [
-  #       { label: "Home", url: "/" },
-  #       { label: "<%= plural_table_name.titleize %>", url: "/<%= plural_table_name %>" }
-  #     ]
-  #   }
-  # end
 end
 <% end -%>

data/lib/generators/serviceable/templates/repository.rb.tt

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+# Repository for <%= class_name %> model data access.
+#
+# Provides a clean abstraction layer between services and ActiveRecord.
+# The model class is automatically inferred from the repository name:
+#   <%= class_name %>Repository -> <%= class_name %>
+#
+# Inherited methods from BaseRepository:
+# - find(id), find_by(attributes), where(conditions)
+# - create(attributes), create!(attributes)
+# - update(record, attributes), update!(record, attributes)
+# - destroy(record), destroy!(record)
+# - search(predicates, page:, per_page:, includes:, order:)
+# - all, count, exists?
+#
+# @example Basic usage
+#   repo = <%= class_name %>Repository.new
+#   repo.find(1)
+#   repo.search({ status_eq: 'active' }, page: 1, per_page: 20)
+#
+# @example In services (via RepositoryAware)
+#   class <%= class_name %>::IndexService < <%= class_name %>::BaseService
+#     search_with do
+#       { items: <%= singular_table_name %>_repository.active.recent.to_a }
+#     end
+#   end
+#
+class <%= class_name %>Repository < BetterService::Repository::BaseRepository
+  # Model is inferred automatically: <%= class_name %>Repository -> <%= class_name %>
+  # Override with explicit model if needed:
+  # def initialize(model_class = <%= class_name %>)
+  #   super
+  # end
+
+  # Add custom repository methods below:
+
+  # @example Scope methods
+  # def active
+  #   where(active: true)
+  # end
+  #
+  # def inactive
+  #   where(active: false)
+  # end
+
+  # @example Ownership methods
+  # def for_user(user)
+  #   where(user_id: user.id)
+  # end
+  #
+  # def for_organization(org)
+  #   where(organization_id: org.id)
+  # end
+
+  # @example Ordering methods
+  # def recent(limit = 10)
+  #   model.order(created_at: :desc).limit(limit)
+  # end
+  #
+  # def by_name
+  #   model.order(:name)
+  # end
+
+  # @example Complex queries
+  # def with_associations
+  #   model.includes(:user, :category)
+  # end
+  #
+  # def published_today
+  #   where(published: true)
+  #     .where("published_at >= ?", Time.current.beginning_of_day)
+  # end
+end
+<% end -%>

data/lib/generators/serviceable/templates/repository_test.rb.tt

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>RepositoryTest < ActiveSupport::TestCase
+  def setup
+    @repository = <%= class_name %>Repository.new
+  end
+
+  # Model inference tests
+  test "repository infers model class correctly" do
+    assert_equal <%= class_name %>, @repository.model
+  end
+
+  # Basic CRUD operation tests
+  # Uncomment and adjust based on your fixtures/factories
+
+  # test "all returns collection" do
+  #   records = @repository.all
+  #   assert_respond_to records, :each
+  #   assert_kind_of ActiveRecord::Relation, records
+  # end
+
+  # test "find returns record by id" do
+  #   record = <%= plural_table_name %>(:one)
+  #   found = @repository.find(record.id)
+  #   assert_equal record, found
+  # end
+
+  # test "find raises for non-existent record" do
+  #   assert_raises(ActiveRecord::RecordNotFound) do
+  #     @repository.find(-1)
+  #   end
+  # end
+
+  # test "find_by returns matching record" do
+  #   record = <%= plural_table_name %>(:one)
+  #   found = @repository.find_by(id: record.id)
+  #   assert_equal record, found
+  # end
+
+  # test "find_by returns nil for no match" do
+  #   found = @repository.find_by(id: -1)
+  #   assert_nil found
+  # end
+
+  # test "where returns filtered collection" do
+  #   records = @repository.where(active: true)
+  #   assert_kind_of ActiveRecord::Relation, records
+  # end
+
+  # test "count returns number of records" do
+  #   count = @repository.count
+  #   assert_kind_of Integer, count
+  # end
+
+  # test "exists? returns boolean" do
+  #   assert_includes [true, false], @repository.exists?(id: 1)
+  # end
+
+  # Create operation tests
+
+  # test "create persists new record" do
+  #   assert_difference '<%= class_name %>.count' do
+  #     @repository.create(valid_attributes)
+  #   end
+  # end
+
+  # test "create! raises on invalid attributes" do
+  #   assert_raises(ActiveRecord::RecordInvalid) do
+  #     @repository.create!(invalid_attributes)
+  #   end
+  # end
+
+  # Update operation tests
+
+  # test "update modifies record" do
+  #   record = <%= plural_table_name %>(:one)
+  #   @repository.update(record, name: "Updated Name")
+  #   record.reload
+  #   assert_equal "Updated Name", record.name
+  # end
+
+  # Destroy operation tests
+
+  # test "destroy removes record" do
+  #   record = <%= plural_table_name %>(:one)
+  #   assert_difference '<%= class_name %>.count', -1 do
+  #     @repository.destroy(record)
+  #   end
+  # end
+
+  # Search operation tests (if using predicates)
+
+  # test "search with predicates returns filtered results" do
+  #   results = @repository.search({ active_eq: true }, limit: nil)
+  #   assert results.all?(&:active)
+  # end
+
+  # test "search with pagination" do
+  #   results = @repository.search({}, page: 1, per_page: 10)
+  #   assert results.size <= 10
+  # end
+
+  private
+
+  # Define valid attributes for create tests
+  # def valid_attributes
+  #   {
+  #     name: "Test <%= human_name %>",
+  #     # Add other required attributes
+  #   }
+  # end
+
+  # Define invalid attributes for validation tests
+  # def invalid_attributes
+  #   {
+  #     name: nil,
+  #     # Add attributes that should fail validation
+  #   }
+  # end
+end
+<% end -%>