light-services 2.2.1 → 3.0.0

data/lib/generators/light_services/service/service_generator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module LightServices
+  module Generators
+    class ServiceGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      argument :name, type: :string, required: true,
+                      desc: "The name of the service (e.g., user/create or CreateUser)"
+
+      class_option :args, type: :array, default: [],
+                          desc: "List of arguments for the service"
+      class_option :steps, type: :array, default: [],
+                           desc: "List of steps for the service"
+      class_option :outputs, type: :array, default: [],
+                             desc: "List of outputs for the service"
+      class_option :skip_spec, type: :boolean, default: false,
+                               desc: "Skip creating the spec file"
+      class_option :parent, type: :string, default: "ApplicationService",
+                            desc: "Parent class for the service"
+
+      desc "Creates a new service class"
+
+      def create_service_file
+        template "service.rb.tt", "app/services/#{file_path}.rb"
+      end
+
+      def create_spec_file
+        return if options[:skip_spec]
+        return unless rspec_installed?
+
+        template "service_spec.rb.tt", "spec/services/#{file_path}_spec.rb"
+      end
+
+      private
+
+      def file_path
+        name.underscore
+      end
+
+      def class_name
+        name.camelize
+      end
+
+      def parent_class
+        options[:parent]
+      end
+
+      def arguments
+        options[:args]
+      end
+
+      def steps
+        options[:steps]
+      end
+
+      def outputs
+        options[:outputs]
+      end
+
+      def rspec_installed?
+        File.directory?(File.join(destination_root, "spec"))
+      end
+    end
+  end
+end

data/lib/generators/light_services/service/templates/service.rb.tt

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class <%= class_name %> < <%= parent_class %>
+<% if arguments.any? -%>
+  # Arguments
+<% arguments.each do |arg| -%>
+  arg :<%= arg %>
+<% end -%>
+
+<% end -%>
+<% if steps.any? -%>
+  # Steps
+<% steps.each do |step| -%>
+  step :<%= step %>
+<% end -%>
+
+<% end -%>
+<% if outputs.any? -%>
+  # Outputs
+<% outputs.each do |output| -%>
+  output :<%= output %>
+<% end -%>
+
+<% end -%>
+<% if steps.empty? -%>
+  # step :step_a
+  # step :step_b
+
+<% end -%>
+  private
+
+<% if steps.any? -%>
+<% steps.each_with_index do |step, index| -%>
+  def <%= step %>
+    # TODO: Implement <%= step %>
+  end
+<%= "\n" unless index == steps.length - 1 -%>
+<% end -%>
+<% else -%>
+  # def step_a
+  #   # TODO: Implement service logic
+  # end
+
+  # def step_b
+  #   # TODO: Implement service logic
+  # end
+<% end -%>
+end

data/lib/generators/light_services/service/templates/service_spec.rb.tt

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+# TODO: Add test implementation
+RSpec.describe <%= class_name %>, type: :service do
+<% if arguments.any? -%>
+  describe "arguments" do
+<% arguments.each do |arg| -%>
+    it { is_expected.to define_argument(:<%= arg %>) }
+<% end -%>
+  end
+
+<% end -%>
+<% if steps.any? -%>
+  describe "steps" do
+<% steps.each do |step| -%>
+    it { is_expected.to define_step(:<%= step %>) }
+<% end -%>
+  end
+
+<% end -%>
+<% if outputs.any? -%>
+  describe "outputs" do
+<% outputs.each do |output| -%>
+    it { is_expected.to define_output(:<%= output %>) }
+<% end -%>
+  end
+
+<% end -%>
+  describe "#run" do
+    subject(:service) { described_class.run(args) }
+
+    let(:args) { {} }
+
+    it "succeeds" do
+      expect(service).to be_success
+    end
+  end
+end

data/lib/light/services/base.rb

@@ -1,38 +1,34 @@
 # frozen_string_literal: true
 
-require "benchmark"
-
+require "light/services/constants"
 require "light/services/message"
 require "light/services/messages"
 require "light/services/base_with_context"
 
 require "light/services/settings/step"
-require "light/services/settings/output"
-require "light/services/settings/argument"
+require "light/services/settings/field"
+
+require "light/services/collection"
 
-require "light/services/collection/base"
-require "light/services/collection/outputs"
-require "light/services/collection/arguments"
+require "light/services/dsl/arguments_dsl"
+require "light/services/dsl/outputs_dsl"
+require "light/services/dsl/steps_dsl"
 
-require "light/services/class_based_collection/base"
-require "light/services/class_based_collection/mount"
+require "light/services/concerns/execution"
+require "light/services/concerns/state_management"
+require "light/services/concerns/parent_service"
 
 # Base class for all service objects
 module Light
   module Services
     class Base
-      # Includes
-      extend ClassBasedCollection::Mount
-
-      # Settings
-      mount_class_based_collection :steps,     item_class: Settings::Step,     shortcut: :step
-      mount_class_based_collection :outputs,   item_class: Settings::Output,   shortcut: :output
-      mount_class_based_collection :arguments, item_class: Settings::Argument, shortcut: :arg, allow_redefine: true
-
-      # Arguments
-      arg :verbose, default: false
-      arg :benchmark, default: false
-      arg :deepness, default: 0, context: true
+      include Callbacks
+      include Dsl::ArgumentsDsl
+      include Dsl::OutputsDsl
+      include Dsl::StepsDsl
+      include Concerns::Execution
+      include Concerns::StateManagement
+      include Concerns::ParentService
 
       # Getters
       attr_reader :outputs, :arguments, :errors, :warnings
@@ -41,8 +37,8 @@ module Light
         @config = Light::Services.config.merge(self.class.class_config || {}).merge(config)
         @parent_service = parent_service
 
-        @outputs = Collection::Outputs.new(self)
-        @arguments = Collection::Arguments.new(self, args.dup)
+        @outputs = Collection::Base.new(self, CollectionTypes::OUTPUTS)
+        @arguments = Collection::Base.new(self, CollectionTypes::ARGUMENTS, args.dup)
 
         @done = false
         @launched_steps = []
@@ -77,20 +73,14 @@ module Light
 
       def call
         load_defaults_and_validate
-        log_header if benchmark? || verbose?
 
-        time = Benchmark.ms do
-          run_steps
-          run_steps_with_always
+        run_callbacks(:before_service_run, self)
 
-          copy_warnings_to_parent_service
-          copy_errors_to_parent_service
+        run_callbacks(:around_service_run, self) do
+          execute_service
         end
 
-        return unless benchmark
-
-        log "🟢 Finished #{self.class} in #{time}ms"
-        puts
+        run_service_result_callbacks
       rescue StandardError => e
         run_steps_with_always
         raise e
@@ -118,86 +108,6 @@ module Light
           BaseWithContext.new(self, service, config.dup)
         end
       end
-
-      # TODO: Add possibility to specify logger
-      def log(message)
-        puts "#{'  ' * deepness}→ #{message}"
-      end
-
-      private
-
-      def initialize_errors
-        @errors = Messages.new(
-          break_on_add: @config[:break_on_error],
-          raise_on_add: @config[:raise_on_error],
-          rollback_on_add: @config[:use_transactions] && @config[:rollback_on_error]
-        )
-      end
-
-      def initialize_warnings
-        @warnings = Messages.new(
-          break_on_add: @config[:break_on_warning],
-          raise_on_add: @config[:raise_on_warning],
-          rollback_on_add: @config[:use_transactions] && @config[:rollback_on_warning]
-        )
-      end
-
-      def run_steps
-        within_transaction do
-          self.class.steps.each do |name, step|
-            @launched_steps << name if step.run(self, benchmark: benchmark)
-
-            break if @errors.break? || @warnings.break?
-          end
-        end
-      end
-
-      # Run steps with parameter `always` if they weren't launched because of errors/warnings
-      def run_steps_with_always
-        self.class.steps.each do |name, step|
-          next if !step.always || @launched_steps.include?(name)
-
-          @launched_steps << name if step.run(self)
-        end
-      end
-
-      def copy_warnings_to_parent_service
-        return if !@parent_service || !@config[:load_warnings]
-
-        @parent_service.warnings.copy_from(
-          @warnings,
-          break: @config[:self_break_on_warning],
-          rollback: @config[:self_rollback_on_warning]
-        )
-      end
-
-      def copy_errors_to_parent_service
-        return if !@parent_service || !@config[:load_errors]
-
-        @parent_service.errors.copy_from(
-          @errors,
-          break: @config[:self_break_on_error],
-          rollback: @config[:self_rollback_on_error]
-        )
-      end
-
-      def load_defaults_and_validate
-        @outputs.load_defaults
-        @arguments.load_defaults
-        @arguments.validate!
-      end
-
-      def log_header
-        log "🏎 Run service #{self.class}"
-      end
-
-      def within_transaction(&block)
-        if @config[:use_transactions] && defined?(ActiveRecord::Base)
-          ActiveRecord::Base.transaction(requires_new: true, &block)
-        else
-          yield
-        end
-      end
     end
   end
 end

data/lib/light/services/callbacks.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Light
+  module Services
+    module Callbacks
+      EVENTS = [
+        :before_step_run,
+        :after_step_run,
+        :around_step_run,
+        :on_step_success,
+        :on_step_failure,
+        :on_step_crash,
+        :before_service_run,
+        :after_service_run,
+        :around_service_run,
+        :on_service_success,
+        :on_service_failure,
+      ].freeze
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Define DSL methods for each callback event
+        EVENTS.each do |event|
+          define_method(event) do |method_name = nil, &block|
+            callback = method_name || block
+            raise ArgumentError, "#{event} requires a method name (symbol) or a block" unless callback
+
+            unless callback.is_a?(Symbol) || callback.is_a?(Proc)
+              raise ArgumentError,
+                    "#{event} callback must be a Symbol or Proc"
+            end
+
+            callbacks_for(event) << callback
+          end
+        end
+
+        # Get all callbacks for a specific event (including inherited ones)
+        def callbacks_for(event)
+          @callbacks ||= {}
+          @callbacks[event] ||= []
+        end
+
+        # Get all callbacks including inherited ones
+        def all_callbacks_for(event)
+          if superclass.respond_to?(:all_callbacks_for)
+            inherited = superclass.all_callbacks_for(event)
+          else
+            inherited = []
+          end
+
+          inherited + callbacks_for(event)
+        end
+      end
+
+      # Run callbacks for a given event
+      # For around callbacks, yields to the block
+      # For other callbacks, just executes them in order
+      def run_callbacks(event, *args, &block)
+        callbacks = self.class.all_callbacks_for(event)
+
+        if event.to_s.start_with?("around_")
+          run_around_callbacks(callbacks, args, &block)
+        else
+          run_simple_callbacks(callbacks, args)
+          yield if block_given?
+        end
+      end
+
+      private
+
+      def run_simple_callbacks(callbacks, args)
+        callbacks.each do |callback|
+          execute_callback(callback, args)
+        end
+      end
+
+      def run_around_callbacks(callbacks, args, &block)
+        return yield if callbacks.empty?
+
+        # Build a chain of around callbacks
+        chain = callbacks.reverse.reduce(block) do |next_block, callback|
+          proc { execute_callback(callback, args, &next_block) }
+        end
+
+        chain.call
+      end
+
+      def execute_callback(callback, args, &block)
+        case callback
+        in Symbol
+          block_given? ? send(callback, *args, &block) : send(callback, *args)
+        in Proc
+          block_given? ? instance_exec(*args, block, &callback) : instance_exec(*args, &callback)
+        else
+          raise ArgumentError, "Callback must be a Symbol or Proc, got #{callback.class}"
+        end
+      end
+    end
+  end
+end

data/lib/light/services/collection.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+# Collection to store arguments and outputs values
+module Light
+  module Services
+    module Collection
+      class Base
+        extend Forwardable
+
+        def_delegators :@storage, :key?, :to_h
+
+        def initialize(instance, collection_type, storage = {})
+          validate_collection_type!(collection_type)
+
+          @instance = instance
+          @collection_type = collection_type
+          @storage = storage
+
+          return if storage.is_a?(Hash)
+
+          raise Light::Services::ArgTypeError, "#{instance.class} - #{collection_type} must be a Hash"
+        end
+
+        def set(key, value)
+          @storage[key] = value
+        end
+
+        def get(key)
+          @storage[key]
+        end
+
+        def [](key)
+          get(key)
+        end
+
+        def []=(key, value)
+          set(key, value)
+        end
+
+        def load_defaults
+          settings_collection.each do |name, settings|
+            next if !settings.default_exists || key?(name)
+
+            if settings.default.is_a?(Proc)
+              set(name, @instance.instance_exec(&settings.default))
+            else
+              set(name, Utils.deep_dup(settings.default))
+            end
+          end
+        end
+
+        def validate!
+          settings_collection.each do |name, field|
+            next if field.optional && (!key?(name) || get(name).nil?)
+
+            # validate_type! returns the (possibly coerced) value
+            coerced_value = field.validate_type!(get(name))
+            # Store the coerced value back (supports dry-types coercion)
+            set(name, coerced_value) if coerced_value != get(name)
+          end
+        end
+
+        # Extend args with context values (only for arguments)
+        def extend_with_context(args)
+          return args unless @collection_type == CollectionTypes::ARGUMENTS
+
+          settings_collection.each do |name, field|
+            next if !field.context || args.key?(name) || !key?(name)
+
+            args[field.name] = get(name)
+          end
+
+          args
+        end
+
+        private
+
+        def validate_collection_type!(type)
+          return if CollectionTypes::ALL.include?(type)
+
+          raise ArgumentError,
+                "collection_type must be one of #{CollectionTypes::ALL.join(', ')}, got: #{type.inspect}"
+        end
+
+        def settings_collection
+          @instance.class.public_send(@collection_type)
+        end
+      end
+
+      # Aliases for backwards compatibility
+      Arguments = Base
+      Outputs = Base
+    end
+  end
+end

data/lib/light/services/concerns/execution.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Light
+  module Services
+    module Concerns
+      # Handles service execution logic including steps and validation
+      module Execution
+        private
+
+        # Execute the main service logic
+        def execute_service
+          self.class.validate_steps!
+          run_steps
+          run_steps_with_always
+          @outputs.validate! if success?
+
+          copy_warnings_to_parent_service
+          copy_errors_to_parent_service
+        end
+
+        # Run all service result callbacks based on success/failure
+        def run_service_result_callbacks
+          run_callbacks(:after_service_run, self)
+
+          if success?
+            run_callbacks(:on_service_success, self)
+          else
+            run_callbacks(:on_service_failure, self)
+          end
+        end
+
+        # Run normal steps within transaction
+        def run_steps
+          within_transaction do
+            # Cache steps once for both normal and always execution
+            @cached_steps = self.class.steps
+
+            @cached_steps.each do |name, step|
+              @launched_steps << name if step.run(self)
+
+              break if @errors.break? || @warnings.break?
+            end
+          end
+        end
+
+        # Run steps with parameter `always` if they weren't launched because of errors/warnings
+        def run_steps_with_always
+          # Use cached steps from run_steps, or get them if run_steps wasn't called
+          steps_to_check = @cached_steps || self.class.steps
+
+          steps_to_check.each do |name, step|
+            next if !step.always || @launched_steps.include?(name)
+
+            @launched_steps << name if step.run(self)
+          end
+        end
+
+        # Load defaults for outputs and arguments, then validate arguments
+        def load_defaults_and_validate
+          @outputs.load_defaults
+          @arguments.load_defaults
+          @arguments.validate!
+        end
+
+        # Execute block within transaction if configured
+        def within_transaction(&block)
+          if @config[:use_transactions] && defined?(ActiveRecord::Base)
+            ActiveRecord::Base.transaction(requires_new: true, &block)
+          else
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/light/services/concerns/parent_service.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Light
+  module Services
+    module Concerns
+      # Handles copying errors and warnings to parent services
+      module ParentService
+        private
+
+        # Copy warnings from this service to parent service
+        def copy_warnings_to_parent_service
+          return if !@parent_service || !@config[:load_warnings]
+
+          @parent_service.warnings.copy_from(
+            @warnings,
+            break: @config[:self_break_on_warning],
+            rollback: @config[:self_rollback_on_warning],
+          )
+        end
+
+        # Copy errors from this service to parent service
+        def copy_errors_to_parent_service
+          return if !@parent_service || !@config[:load_errors]
+
+          @parent_service.errors.copy_from(
+            @errors,
+            break: @config[:self_break_on_error],
+            rollback: @config[:self_rollback_on_error],
+          )
+        end
+      end
+    end
+  end
+end

data/lib/light/services/concerns/state_management.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Light
+  module Services
+    module Concerns
+      # Manages service state including errors and warnings initialization
+      module StateManagement
+        private
+
+        # Initialize errors collection with configuration
+        def initialize_errors
+          @errors = Messages.new(
+            break_on_add: @config[:break_on_error],
+            raise_on_add: @config[:raise_on_error],
+            rollback_on_add: @config[:use_transactions] && @config[:rollback_on_error],
+          )
+        end
+
+        # Initialize warnings collection with configuration
+        def initialize_warnings
+          @warnings = Messages.new(
+            break_on_add: @config[:break_on_warning],
+            raise_on_add: @config[:raise_on_warning],
+            rollback_on_add: @config[:use_transactions] && @config[:rollback_on_warning],
+          )
+        end
+      end
+    end
+  end
+end