better_service 1.0.0

data/lib/generators/serviceable/create_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Serviceable
+  module Generators
+    class CreateGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generate a Create service for creating new resources"
+
+      def create_service_file
+        template "create_service.rb.tt", File.join("app/services", class_path, "#{file_name}/create_service.rb")
+      end
+
+      def create_test_file
+        template "service_test.rb.tt", File.join("test/services", class_path, "#{file_name}/create_service_test.rb")
+      end
+
+      private
+
+      def service_class_name
+        "#{class_name}::CreateService"
+      end
+    end
+  end
+end

data/lib/generators/serviceable/destroy_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Serviceable
+  module Generators
+    class DestroyGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generate a Destroy service for deleting resources"
+
+      def create_service_file
+        template "destroy_service.rb.tt", File.join("app/services", class_path, "#{file_name}/destroy_service.rb")
+      end
+
+      def create_test_file
+        template "service_test.rb.tt", File.join("test/services", class_path, "#{file_name}/destroy_service_test.rb")
+      end
+
+      private
+
+      def service_class_name
+        "#{class_name}::DestroyService"
+      end
+    end
+  end
+end

data/lib/generators/serviceable/index_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Serviceable
+  module Generators
+    class IndexGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generate an Index service for listing resources"
+
+      def create_service_file
+        template "index_service.rb.tt", File.join("app/services", class_path, "#{file_name}/index_service.rb")
+      end
+
+      def create_test_file
+        template "service_test.rb.tt", File.join("test/services", class_path, "#{file_name}/index_service_test.rb")
+      end
+
+      private
+
+      def service_class_name
+        "#{class_name}::IndexService"
+      end
+    end
+  end
+end

data/lib/generators/serviceable/scaffold_generator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Serviceable
+  module Generators
+    class ScaffoldGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :skip_index, type: :boolean, default: false, desc: "Skip Index service generation"
+      class_option :skip_show, type: :boolean, default: false, desc: "Skip Show service generation"
+      class_option :skip_create, type: :boolean, default: false, desc: "Skip Create service generation"
+      class_option :skip_update, type: :boolean, default: false, desc: "Skip Update service generation"
+      class_option :skip_destroy, type: :boolean, default: false, desc: "Skip Destroy service generation"
+
+      desc "Generate all CRUD services (Index, Show, Create, Update, Destroy)"
+
+      def generate_index_service
+        return if options[:skip_index]
+
+        say "Generating Index service...", :green
+        generate "serviceable:index", name
+      end
+
+      def generate_show_service
+        return if options[:skip_show]
+
+        say "Generating Show service...", :green
+        generate "serviceable:show", name
+      end
+
+      def generate_create_service
+        return if options[:skip_create]
+
+        say "Generating Create service...", :green
+        generate "serviceable:create", name
+      end
+
+      def generate_update_service
+        return if options[:skip_update]
+
+        say "Generating Update service...", :green
+        generate "serviceable:update", name
+      end
+
+      def generate_destroy_service
+        return if options[:skip_destroy]
+
+        say "Generating Destroy service...", :green
+        generate "serviceable:destroy", name
+      end
+
+      def show_completion_message
+        say "\n" + "=" * 80
+        say "Scaffold generation completed! 🎉", :green
+        say "=" * 80
+        say "\nGenerated services:"
+        say "  - #{class_name}::IndexService" unless options[:skip_index]
+        say "  - #{class_name}::ShowService" unless options[:skip_show]
+        say "  - #{class_name}::CreateService" unless options[:skip_create]
+        say "  - #{class_name}::UpdateService" unless options[:skip_update]
+        say "  - #{class_name}::DestroyService" unless options[:skip_destroy]
+        say "\nNext steps:"
+        say "  1. Review and customize the generated services"
+        say "  2. Update schemas with your specific validations"
+        say "  3. Run the tests: rails test test/services/#{file_name}\n\n"
+      end
+    end
+  end
+end

data/lib/generators/serviceable/show_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Serviceable
+  module Generators
+    class ShowGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generate a Show service for displaying a single resource"
+
+      def create_service_file
+        template "show_service.rb.tt", File.join("app/services", class_path, "#{file_name}/show_service.rb")
+      end
+
+      def create_test_file
+        template "service_test.rb.tt", File.join("test/services", class_path, "#{file_name}/show_service_test.rb")
+      end
+
+      private
+
+      def service_class_name
+        "#{class_name}::ShowService"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>::<%= action_name.camelize %>Service < BetterService::Services::ActionService
+  action_name :<%= action_name %>
+
+  # Schema for validating params
+  schema do
+    required(:id).filled
+    # Add your action-specific params here
+  end
+
+  # Authorization (optional) - Runs BEFORE search phase
+  # Uncomment and customize for your needs:
+  #
+  # authorize_with do
+  #   # Example: Check if user can perform this action
+  #   user.can_<%= action_name %>?
+  #
+  #   # Or use Pundit
+  #   <%= class_name %>Policy.new(user, <%= class_name %>.find(params[:id])).<%= action_name %>?
+  # end
+
+  # Phase 1: Search - Load the resource
+  search_with do
+    { resource: user.<%= plural_table_name %>.find(params[:id]) }
+  end
+
+  # Phase 2: Process - Perform the action
+  process_with do |data|
+    <%= file_name %> = data[:resource]
+    # Add your action logic here
+    # Example: <%= file_name %>.update!(status: '<%= action_name %>', <%= action_name %>_at: Time.current)
+    { resource: <%= file_name %> }
+  end
+
+  # Phase 4: Respond - Format response (optional override)
+  respond_with do |data|
+    success_result("<%= human_name %> <%= action_name %> successfully", data)
+  end
+end
+<% end -%>

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

@@ -0,0 +1,33 @@
+# 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
+
+  # Schema for validating params
+  schema do
+    # Add your required attributes here
+    # Example:
+    # required(:title).filled(:string)
+    # required(:description).maybe(:string)
+  end
+
+  # Phase 1: Search - Prepare dependencies (optional)
+  search_with do
+    {}
+  end
+
+  # Phase 2: Process - Create the resource (runs in transaction)
+  process_with do |data|
+    <%= file_name %> = user.<%= plural_table_name %>.create!(params)
+    { resource: <%= file_name %> }
+  end
+
+  # Phase 4: Respond - Format response (optional override)
+  respond_with do |data|
+    success_result("<%= human_name %> created successfully", data)
+  end
+end
+<% end -%>

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

@@ -0,0 +1,40 @@
+# 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
+
+  # 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]) }
+  end
+
+  # Phase 2: Process - Delete the resource (runs in transaction)
+  process_with do |data|
+    <%= file_name %> = data[:resource]
+    <%= file_name %>.destroy!
+    { resource: <%= file_name %> }
+  end
+
+  # Phase 4: Respond - Format response (optional override)
+  respond_with do |data|
+    success_result("<%= human_name %> deleted successfully", data)
+  end
+end
+<% end -%>

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>::IndexService < BetterService::Services::IndexService
+  # Schema for validating params
+  schema do
+    optional(:page).filled(:integer, gteq?: 1)
+    optional(:per_page).filled(:integer, gteq?: 1, lteq?: 100)
+    optional(:search).maybe(:string)
+  end
+
+  # Phase 1: Search - Load raw data
+  search_with do
+    <%= 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 }
+  end
+
+  # Phase 2: Process - Transform and aggregate data
+  process_with do |data|
+    {
+      items: data[:items],
+      metadata: {
+        stats: {
+          total: data[:items].count
+        },
+        pagination: {
+          page: params[:page] || 1,
+          per_page: params[:per_page] || 25
+        }
+      }
+    }
+  end
+
+  # Phase 4: Respond - Format response (optional override)
+  respond_with do |data|
+    success_result("<%= plural_table_name.titleize %> loaded successfully", data)
+  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/service_test.rb.tt

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= service_class_name %>Test < ActiveSupport::TestCase
+  def setup
+    @user = users(:one) # Assumes you have fixtures
+  end
+
+  test "service executes successfully" do
+    service = <%= service_class_name %>.new(@user)
+    result = service.call
+
+    assert result[:success]
+    assert result.key?(:metadata)
+  end
+
+  test "service validates params" do
+    # Add validation tests based on your schema
+  end
+end
+<% end -%>

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>::ShowService < BetterService::Services::ShowService
+  # Schema for validating params
+  schema do
+    required(:id).filled
+  end
+
+  # Phase 1: Search - Load the resource
+  search_with do
+    { resource: user.<%= plural_table_name %>.find(params[:id]) }
+  end
+
+  # Phase 2: Process - Transform data (optional)
+  # process_with do |data|
+  #   data
+  # end
+
+  # Phase 4: Respond - Format response (optional override)
+  respond_with do |data|
+    success_result("<%= human_name %> loaded successfully", data)
+  end
+
+  # Phase 5: Viewer - UI configuration (optional)
+  # viewer do |processed, transformed, result|
+  #   {
+  #     page_title: "<%= human_name %> ##{result[:resource].id}",
+  #     breadcrumbs: [
+  #       { label: "Home", url: "/" },
+  #       { label: "<%= plural_table_name.titleize %>", url: "/<%= plural_table_name %>" },
+  #       { label: "Show", url: "#" }
+  #     ]
+  #   }
+  # end
+end
+<% end -%>

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>::UpdateService < BetterService::Services::UpdateService
+  # Database transactions are ENABLED by default for update operations
+  # The process block will automatically run inside a transaction
+  # To disable: with_transaction false
+
+  # Schema for validating params
+  schema do
+    required(:id).filled
+    # Add your optional attributes here
+  end
+
+  # Authorization (optional) - Runs BEFORE search phase
+  # Uncomment and customize for your needs:
+  #
+  # authorize_with do
+  #   # Example 1: Simple role check
+  #   user.admin?
+  #
+  #   # Example 2: Resource ownership check
+  #   <%= file_name %> = <%= class_name %>.find(params[:id])
+  #   <%= file_name %>.user_id == user.id
+  #
+  #   # Example 3: Pundit integration
+  #   <%= class_name %>Policy.new(user, <%= class_name %>.find(params[:id])).update?
+  #
+  #   # Example 4: CanCanCan integration
+  #   Ability.new(user).can?(:update, :<%= file_name %>)
+  # end
+
+  # Phase 1: Search - Load the resource
+  search_with do
+    { resource: user.<%= plural_table_name %>.find(params[:id]) }
+  end
+
+  # Phase 2: Process - Update the resource (runs in transaction)
+  process_with do |data|
+    <%= file_name %> = data[:resource]
+    <%= file_name %>.update!(params.except(:id))
+    { resource: <%= file_name %> }
+  end
+
+  # Phase 4: Respond - Format response (optional override)
+  respond_with do |data|
+    success_result("<%= human_name %> updated successfully", data)
+  end
+end
+<% end -%>

data/lib/generators/serviceable/update_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Serviceable
+  module Generators
+    class UpdateGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generate an Update service for modifying resources"
+
+      def create_service_file
+        template "update_service.rb.tt", File.join("app/services", class_path, "#{file_name}/update_service.rb")
+      end
+
+      def create_test_file
+        template "service_test.rb.tt", File.join("test/services", class_path, "#{file_name}/update_service_test.rb")
+      end
+
+      private
+
+      def service_class_name
+        "#{class_name}::UpdateService"
+      end
+    end
+  end
+end

data/lib/generators/workflowable/WORKFLOW_README

@@ -0,0 +1,27 @@
+===============================================================================
+
+Workflow has been generated!
+
+Next steps:
+
+1. Define your workflow steps in the generated file
+2. Create the service classes referenced in each step
+3. Implement the input mapping for each step to pass data between services
+4. Add any lifecycle hooks (before_workflow, after_workflow, around_step)
+5. Configure transaction support if needed with: with_transaction true
+
+Usage example:
+
+  result = YourWorkflow.new(current_user, params: { ... }).call
+
+  if result[:success]
+    # Access context data
+    resource = result[:context].resource_name
+  else
+    # Handle errors
+    errors = result[:errors]
+  end
+
+For more information, see the BetterService documentation.
+
+===============================================================================

data/lib/generators/workflowable/templates/workflow.rb.tt

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= workflow_class_name %> < BetterService::Workflow
+<% if use_transaction -%>
+  # Enable database transactions for the entire workflow
+  with_transaction true
+<% else -%>
+  # Database transactions are DISABLED by default
+  # To enable: with_transaction true
+<% end -%>
+
+  # Lifecycle hooks (optional)
+  # before_workflow :validate_prerequisites
+  # after_workflow :cleanup_resources
+  # around_step :log_step_execution
+
+<% if workflow_steps.any? -%>
+  # Define workflow steps
+<% workflow_steps.each do |step_name| -%>
+  step :<%= step_name %>,
+       with: <%= class_name %>::<%= step_name.to_s.camelize %>Service,
+       input: ->(ctx) {
+         # Map context data to service params
+         # Example: { resource_id: ctx.resource.id, amount: ctx.amount }
+         {}
+       }
+       # Optional configuration:
+       # optional: true  # Step won't stop workflow if it fails
+       # if: ->(ctx) { ctx.some_condition? }  # Conditional execution
+       # rollback: ->(ctx) { ctx.resource.destroy! }  # Rollback logic
+
+<% end -%>
+<% else -%>
+  # Example step configuration:
+  #
+  # step :create_resource,
+  #      with: <%= class_name %>::CreateService,
+  #      input: ->(ctx) { { name: ctx.resource_name, user_id: ctx.user.id } }
+  #
+  # step :process_payment,
+  #      with: Payment::ChargeService,
+  #      input: ->(ctx) { { amount: ctx.resource.total, payment_method: ctx.payment_method } },
+  #      rollback: ->(ctx) { Payment::RefundService.new(ctx.user, params: { charge_id: ctx.charge.id }).call }
+  #
+  # step :send_notification,
+  #      with: Email::NotificationService,
+  #      input: ->(ctx) { { resource_id: ctx.resource.id } },
+  #      optional: true,
+  #      if: ->(ctx) { ctx.user.notifications_enabled? }
+
+<% end -%>
+  private
+
+  # Example lifecycle hooks:
+  #
+  # def validate_prerequisites(context)
+  #   context.fail!("Prerequisites not met") unless some_condition
+  # end
+  #
+  # def cleanup_resources(context)
+  #   # Clean up only on success
+  #   context.user.clear_cache! if context.success?
+  # end
+  #
+  # def log_step_execution(step, context)
+  #   Rails.logger.info "Executing step: #{step.name}"
+  #   yield  # Execute the step
+  #   Rails.logger.info "Completed step: #{step.name}"
+  # end
+end
+<% end -%>

data/lib/generators/workflowable/templates/workflow_test.rb.tt

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+<% module_namespacing do -%>
+class <%= workflow_class_name %>Test < ActiveSupport::TestCase
+  # Setup test data
+  setup do
+    @user = users(:one) # Adjust based on your fixtures
+  end
+
+  test "workflow executes successfully with valid params" do
+    params = {
+      # Add your test params here
+    }
+
+    result = <%= workflow_class_name %>.new(@user, params: params).call
+
+    assert result[:success], "Expected workflow to succeed"
+    assert_instance_of BetterService::Workflowable::Context, result[:context]
+    assert_equal "<%= workflow_class_name %>", result[:metadata][:workflow]
+  end
+
+  test "workflow fails with invalid params" do
+    params = {
+      # Add invalid params here
+    }
+
+    result = <%= workflow_class_name %>.new(@user, params: params).call
+
+    assert_not result[:success], "Expected workflow to fail"
+    assert result[:errors].present?
+  end
+
+  test "workflow tracks executed steps" do
+    params = {
+      # Add your test params here
+    }
+
+    result = <%= workflow_class_name %>.new(@user, params: params).call
+
+    assert result[:metadata][:steps_executed].is_a?(Array)
+<% if workflow_steps.any? -%>
+    # Verify expected steps were executed
+<% workflow_steps.each do |step_name| -%>
+    # assert_includes result[:metadata][:steps_executed], :<%= step_name %>
+<% end -%>
+<% end -%>
+  end
+
+<% if use_transaction -%>
+  test "workflow rolls back database changes on failure" do
+    # Test that database changes are rolled back when workflow fails
+    # Example:
+    # assert_no_difference "<%= class_name %>.count" do
+    #   result = <%= workflow_class_name %>.new(@user, params: invalid_params).call
+    #   assert_not result[:success]
+    # end
+  end
+<% end -%>
+end
+<% end -%>