light-service-ext 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5af4ef116e875211e34ed7878338e8e6a6e7a4b2b0a1777bcd685a4d33219e18
-  data.tar.gz: 2cbc4827230fa19f43140d0022a75b308ac516b86eab1fc201358a060b3503c6
+  metadata.gz: 587a60d79dffd34dfbdbdbfc28e024c3a2983310209a8169e555e9ae88c8592b
+  data.tar.gz: 817889b86ce56ae818070d9bf938a34c8efca969729a51a8c4d37d738d20e821
 SHA512:
-  metadata.gz: 640c9a51e52035660e2e2c56ce3573c5d5cf9586897fb8f6e483e6f32ebe3cc54612170d4f851e06837fe4b155f5dd10ce57f100616270f988dafff50ec227d0
-  data.tar.gz: 1d62d1806e54380ed3a66f54dee065fb76a9d7a91aae12c3191e70544f1c1f1b3e4148f6fa7c787e0b438cc3f96640b002cbcfe323342664fc7b5b7c827eed99
+  metadata.gz: 538351e6b9c9050dcc81f91487c4fcd81e48e822589b5b3a77fa39909b733964d383241bd236c9ac199a32b018b8f9c6edf11efa5ef37d4051f1d0d0212810bd
+  data.tar.gz: 8ebd87e41ceb3bb2db3982289ded3281fd0c0234a33f255c95f9ff926b0a1a62231ade022b9c251246b1f1af6ee4ff4e0e5afe9b7e452ad8c8f41a3489022dbd

data/.env.example

@@ -0,0 +1 @@
+export RBENV_VERSION=$(head -n 1 .ruby-version)

data/.gitignore

@@ -18,3 +18,5 @@ Gemfile.lock
 
 # rspec failure tracking
 .rspec_status
+
+.env

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/lib/light-service-ext/application_context.rb

@@ -2,6 +2,8 @@
 
 module LightServiceExt
   class ApplicationContext < LightService::Context
+    attr_reader :error_info
+
     class << self
       def make_with_defaults(input = {}, overrides = {})
         defaults = default_attrs
@@ -23,7 +25,7 @@ module LightServiceExt
           api_responses: [],
           last_failed_context: nil,
           allow_raise_on_failure: LightServiceExt.config.allow_raise_on_failure?,
-          internal_only: { error_info: nil }
+          internal_only: {}
         }.freeze
       end
     end
@@ -61,6 +63,18 @@ module LightServiceExt
       add_attrs_to_ctx(:internal_only, **attrs)
     end
 
+    def record_raised_error(error)
+      @error_info = ErrorInfo.new(error)
+      error_type = @error_info.type
+      error_message = @error_info.message
+      add_internal_only(error_info: { organizer: organizer_name,
+                                      action_name: action_name,
+                                      error: { type: error_type, message: error_message, backtrace: @error_info.clean_backtrace } })
+      add_errors(base: error_message)
+
+      LightServiceExt.config.on_raised_error.call(self, error)
+    end
+
     def add_to_api_responses(*api_response)
       add_collection_to_ctx(:api_responses, *api_response)
     end
@@ -77,6 +91,22 @@ module LightServiceExt
       !!self[:allow_raise_on_failure]
     end
 
+    def organizer_name
+      return nil if organized_by.nil?
+
+      organized_by.name.split('::').last
+    end
+
+    def action_name
+      return nil if invoked_action.blank?
+
+      invoked_action.name.split('::').last
+    end
+
+    def formatted_errors
+      JSON.pretty_generate(errors.presence || {})
+    end
+
     private
 
     def add_value_to_ctx(key, value)

data/lib/light-service-ext/application_organizer.rb

@@ -3,12 +3,15 @@
 module LightServiceExt
   class ApplicationOrganizer
     extend LightService::Organizer
+    extend WithErrorHandler
 
     class << self
       def call(context)
-        with(ApplicationContext.make_with_defaults(context))
-          .around_each(RecordActions)
-          .reduce(all_steps)
+        ctx = ApplicationContext.make_with_defaults(context)
+
+        with_error_handler(ctx: ctx) do
+          with(ctx).around_each(RecordActions).reduce(all_steps)
+        end
       end
 
       def steps

data/lib/light-service-ext/configuration.rb

@@ -7,7 +7,7 @@ module LightServiceExt
     config_accessor(:allow_raise_on_failure) { true }
     config_accessor(:non_fatal_error_classes) { [] }
     config_accessor(:default_non_fatal_error_classes) { ['Rails::ActiveRecordError'.safe_constantize] }
-    config_accessor(:logger) { (defined? Rails.logger).nil? ? Logger.new($stdout) : Rails.logger }
+    config_accessor(:on_raised_error) { proc {|_ctx, _error|} }
 
     def allow_raise_on_failure?
       !!allow_raise_on_failure

data/lib/light-service-ext/error_info.rb

@@ -8,7 +8,7 @@ module LightServiceExt
       @fatal = fatal
       @error = error
       @type = error.class.name
-      @message = message || error&.message
+      @message = message || error.try(:message)
       @title = "#{error.class.name} : #{error&.message}"
     end
 
@@ -30,8 +30,8 @@ module LightServiceExt
     end
 
     def errors
-      model = error && (error.try(:model) || error.try(:record))
-      return model.errors.messages if model.present?
+      model = error.try(:model) || error.try(:record)
+      message = model.present? ? model.errors.messages : error.message
 
       { base: message }
     end
@@ -41,7 +41,7 @@ module LightServiceExt
         type: type,
         message: message,
         exception: title,
-        backtrace: clean_backtrace[0, 3]&.join("\n"),
+        backtrace: clean_backtrace[0, 5]&.join("\n"),
         error: error,
         fatal_error?: fatal_error?,
         errors: errors

data/lib/light-service-ext/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LightServiceExt
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/lib/light-service-ext/with_error_handler.rb

@@ -1,25 +1,15 @@
 # frozen_string_literal: true
 
 # rubocop:disable Metrics/AbcSize
-
 module LightServiceExt
   module WithErrorHandler
     def with_error_handler(ctx:)
       @result = yield || ApplicationContext.make_with_defaults
-    rescue Rails::ActiveRecordError => e
-      error_info = ErrorInfo.new(e, fatal: false)
-      ctx.add_internal_only(error_info: error_info)
-      ctx.add_errors(**error_info.errors)
-
-      LightServiceExt.config.logger.error(error_info.error_summary)
-
+    rescue StandardError => e
+      ctx.record_raised_error(e)
+      ctx.add_status(Status::COMPLETE)
       ctx.fail!
       ctx
-    rescue StandardError => e
-      error_info = ErrorInfo.new(e, fatal: false)
-      LightServiceExt.config.logger.error(error_info.error_summary)
-
-      raise
     end
   end
 end

data/light-service-ext.gemspec

@@ -23,10 +23,10 @@ Gem::Specification.new do |gem|
   gem.metadata["changelog_uri"] = "#{gem.homepage}/CHANGELOG.md"
 
   gem.add_runtime_dependency 'light-service', '~> 0.18', '>= 0.18.0'
-  gem.add_runtime_dependency 'dry-struct', '~> 1.6', '< 2'
+  gem.add_runtime_dependency 'dry-struct', '~> 1.6'
   gem.add_runtime_dependency 'dry-validation', '~> 1.10'
   gem.add_runtime_dependency 'json', '~> 2.6', '>= 2.6.3'
-  gem.add_runtime_dependency 'activesupport', '~> 6', '>= 6.0.6'
+  gem.add_runtime_dependency 'activesupport', '~> 6.0', '>= 6.0.6'
 
   gem.add_development_dependency("rake", "~> 13.0.6")
   gem.add_development_dependency("rspec", "~> 3.12.0")

data/spec/light-service-ext/application_context_spec.rb

@@ -7,6 +7,110 @@ module LightServiceExt
 
     subject(:ctx) { described_class.make_with_defaults(input) }
 
+    describe '#record_raised_error' do
+      let(:error_message) { 'Something went wrong' }
+      let(:error) { RuntimeError.new('Something went wrong') }
+      let(:backtrace) { ['some-backtrace-line'] }
+
+      before do
+        allow(subject).to receive(:organized_by) { ApplicationOrganizer }
+        allow(ctx).to receive(:invoked_action) { ApplicationAction }
+
+        error.set_backtrace(backtrace)
+      end
+
+      it 'records the error and adds it to the errors hash' do
+        subject.record_raised_error(error)
+
+        expect(subject.errors).to eql({ base: error_message })
+        expect(subject.success?).to be_truthy
+
+        internal_only = subject.internal_only
+        expect(internal_only.keys).to eql([:error_info])
+
+        error_info = internal_only[:error_info]
+        expect(error_info.keys).to eql([:organizer, :action_name, :error])
+        expect(error_info[:organizer]).to eql('ApplicationOrganizer')
+        expect(error_info[:action_name]).to eql('ApplicationAction')
+
+        raised_error_info = error_info[:error]
+        expect(raised_error_info.keys).to eql([:type, :message, :backtrace])
+        expect(raised_error_info[:type]).to eql(error.class.name)
+        expect(raised_error_info[:message]).to eql(error_message)
+        expect(raised_error_info[:backtrace]).to eql(error.backtrace)
+      end
+
+      it 'fails the operation and sets the error info' do
+        subject.record_raised_error(error)
+
+        expect(subject.success?).to be(true)
+      end
+    end
+
+    describe '#organizer_name' do
+      context 'with organizer' do
+        before { allow(subject).to receive(:organized_by) { ApplicationOrganizer } }
+
+        it 'returns the name of the organizer class' do
+          expect(subject.organizer_name).to eq('ApplicationOrganizer')
+        end
+      end
+
+      context 'without organizer' do
+        before { allow(subject).to receive(:organized_by) { nil } }
+
+        it 'returns nil' do
+          expect(subject.organizer_name).to be(nil)
+        end
+      end
+    end
+
+    describe '#action_name' do
+      context 'with invoked action' do
+        before { allow(subject).to receive(:invoked_action) { ApplicationAction } }
+
+        it 'returns the name of the organizer class' do
+          expect(subject.action_name).to eq('ApplicationAction')
+        end
+      end
+
+      context 'without invoked action' do
+        before { allow(subject).to receive(:invoked_action) { nil } }
+
+        it 'returns nil' do
+          expect(subject.action_name).to be(nil)
+        end
+      end
+    end
+
+    describe '#formatted_errors' do
+      before { allow(subject).to receive(:errors) { errors } }
+
+      context 'with errors' do
+        let(:errors) { { name: ['is required'], email: ['is invalid'] } }
+
+        it 'returns a JSON string of the errors' do
+          expect(subject.formatted_errors).to eq(JSON.pretty_generate(errors))
+        end
+      end
+
+      context 'without errors' do
+        let(:errors) { {} }
+
+        it 'returns an empty JSON string if there are no errors' do
+          expect(subject.formatted_errors).to eq(JSON.pretty_generate({}))
+        end
+      end
+
+      context 'without errors' do
+        let(:errors) { nil }
+
+        it 'returns an empty JSON string if there are no errors' do
+          expect(subject.formatted_errors).to eq(JSON.pretty_generate({}))
+        end
+      end
+    end
+
     describe '#add_to_successful_actions' do
       it 'adds successful action name to context' do
         ctx.add_to_successful_actions(value)

data/spec/light-service-ext/application_organizer_spec.rb

@@ -24,6 +24,9 @@ module LightServiceExt
 
     let(:input) { { some_proc: proc {} } }
 
+    before { allow_any_instance_of(ApplicationContext).to receive(:organized_by) { ApplicationOrganizer } }
+
+
     it 'adds inputted data as input key value pair' do
       ctx = subject_class.call(input)
 
@@ -32,9 +35,11 @@ module LightServiceExt
     end
 
     it 'calls underlying action' do
-      expect do
-        subject_class.call(some_proc: proc { raise 'error' })
-      end.to raise_error RuntimeError, 'error'
+      ctx = subject_class.call(some_proc: proc { raise 'error' })
+
+      expect(ctx.errors).to be_present
+      expect(ctx).to be_failure
+      expect(ctx.status).to eql(Status::COMPLETE)
     end
   end
 end

data/spec/light-service-ext/configuration_spec.rb

@@ -60,6 +60,33 @@ module LightServiceExt
           end
         end
       end
+
+      describe '#on_raised_error' do
+        it 'returns a proc' do
+          expect(config.on_raised_error).to be_a(Proc)
+        end
+
+        context 'with configured callback' do
+          let(:error) { ArgumentError.new('some-error') }
+          let(:callback) { proc { |_ctx, _error| } }
+
+          before do
+            described_class.configure { |config| config.on_raised_error = callback }
+          end
+
+          after(:each) do
+            described_class.configure { |config| config.on_raised_error = proc {|_ctx, _error|} }
+          end
+
+
+          it 'returns set proc' do
+            ctx = ApplicationContext.make_with_defaults
+            ctx.record_raised_error(error)
+
+            expect(described_class.config.on_raised_error).to eql(callback)
+          end
+        end
+      end
     end
   end
 end

data/spec/light-service-ext/error_info_spec.rb

@@ -9,8 +9,57 @@ RSpec.describe LightServiceExt::ErrorInfo do
   let(:error) { StandardError.new(message) }
   let(:error_info_class) { Class.new(described_class) }
 
-  before do
-    error.set_backtrace(backtrace)
+  describe '#errors' do
+    context 'when error is a StandardError with no associated model or record' do
+      let(:error) { StandardError.new(message) }
+
+      it 'returns a hash with a base error message' do
+        expect(instance.errors).to eq({ base: message })
+      end
+    end
+
+    context 'with stubbed error' do
+      before(:each) do
+        allow(error).to receive(:set_backtrace)
+        allow(error).to receive(:backtrace) { backtrace }
+      end
+
+      context 'when error is associated with a model with validation errors' do
+        let(:model) { double('Model', errors: double(:messages, messages: { field1: ['error1', 'error2'], field2: ['error3'] })) }
+        let(:error) { double('Error', model: model, message: nil) }
+
+        it 'returns a hash with model validation errors' do
+          expect(instance.errors).to eq({ base: { field1: ['error1', 'error2'], field2: ['error3'] } })
+        end
+      end
+
+      context 'when error is associated with a model with no validation errors' do
+        let(:model) { double('Model', errors: double(:messages, messages: {})) }
+        let(:error) { double('Error', model: model, message: nil) }
+
+        it 'returns an empty hash' do
+          expect(instance.errors).to eq({base: {}})
+        end
+      end
+
+      context 'when error is associated with a record with validation errors' do
+        let(:record) { double('Record', errors: double(:messages, messages: { field1: ['error1', 'error2'], field2: ['error3'] })) }
+        let(:error) { double('Error', record: record, message: nil) }
+
+        it 'returns a hash with record validation errors' do
+          expect(instance.errors).to eq({ base: { field1: ['error1', 'error2'], field2: ['error3'] } })
+        end
+      end
+
+      context 'when error is associated with a record with no validation errors' do
+        let(:record) { double('Record', errors: double(:messages, messages: {})) }
+        let(:error) { double('Error', record: record, message: nil) }
+
+        it 'returns an empty hash' do
+          expect(instance.errors).to eq({base: {}})
+        end
+      end
+    end
   end
 
   describe '#type' do
@@ -80,6 +129,8 @@ RSpec.describe LightServiceExt::ErrorInfo do
   end
 
   describe '#error_summary' do
+    before { error.set_backtrace(backtrace) }
+
     it 'returns summary of error' do
       expect(instance.error_summary).to eql(<<~TEXT
         =========== SERVER ERROR FOUND: StandardError : some-error ===========
@@ -96,6 +147,8 @@ RSpec.describe LightServiceExt::ErrorInfo do
   describe '#to_h' do
     subject(:hash) { instance.to_h }
 
+    before { error.set_backtrace(backtrace) }
+
     it 'returns custom key value pairs' do
       expect(hash.keys).to match_array(%i[type message exception backtrace error errors fatal_error?])
 

data/spec/light-service-ext/with_error_handler_spec.rb

@@ -6,52 +6,28 @@ module LightServiceExt
       end
     end
 
-    let(:error_message) { 'some-error' }
     let(:ctx) { ApplicationContext.make_with_defaults }
 
-    before { allow(LightServiceExt.config.logger).to receive(:error) }
+    before do
+      allow(ctx).to receive(:organized_by) { ApplicationOrganizer }
+      allow(ctx).to receive(:invoked_action) { ApplicationAction }
+    end
 
     describe '.with_error_handler' do
-      subject(:errors_handled_ctx) do
-        implementor_class.with_error_handler(ctx: ctx, &results_ctx_proc)
-      end
-
-      context 'with non validation error' do
-        let(:error) { ArgumentError.new(error_message) }
-        let(:results_ctx_proc) { -> { raise error } }
+      let(:error_message) { 'some-error' }
+      let(:error) { RuntimeError.new(error_message) }
+      let(:results_ctx_proc) { -> { raise error } }
 
-        it 'logs errors' do
-          expect { errors_handled_ctx }.to raise_error ArgumentError, error_message
-          expect(LightServiceExt.config.logger).to have_received(:error)
-        end
+      subject(:raised_error_handled_ctx) do
+        implementor_class.with_error_handler(ctx: ctx, &results_ctx_proc)
       end
 
-      context 'with active record error' do
-        let(:key) { :key }
-        let(:key_error) { 'invalid' }
-        let(:messages) { { key => [key_error] } }
-        let(:error) { Rails::ActiveRecordError.new(error_message) }
-        let(:errors) { double(:errors, messages: messages) }
-        let(:model) { double(:model, errors: errors) }
-        let(:results_ctx_proc) { -> { raise error } }
-
-        context 'with error including model' do
-          before { allow(error).to receive(:model) { model } }
-
-          it 'adds model errors' do
-            expect(errors_handled_ctx.failure?).to be_truthy
-            expect(errors_handled_ctx.errors).to eql({ key => [key_error] })
-            expect(errors_handled_ctx.internal_only[:error_info]).to be_an_instance_of(ErrorInfo)
-            expect(LightServiceExt.config.logger).to have_received(:error)
-          end
-        end
+      before { allow(ctx).to receive(:record_raised_error) }
 
-        it 'adds errors to context' do
-          expect(errors_handled_ctx.failure?).to be_truthy
-          expect(errors_handled_ctx.errors).to eql({ base: error_message })
-          expect(errors_handled_ctx.internal_only[:error_info]).to be_an_instance_of(ErrorInfo)
-          expect(LightServiceExt.config.logger).to have_received(:error)
-        end
+      it 'fails context and records error' do
+        expect(raised_error_handled_ctx.failure?).to be_truthy
+        expect(raised_error_handled_ctx).to have_received(:record_raised_error).with(error)
+        expect(raised_error_handled_ctx.status).to eql(Status::COMPLETE)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light-service-ext
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Desmond O'Leary
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-28 00:00:00.000000000 Z
+date: 2023-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: light-service
@@ -37,9 +37,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -47,9 +44,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
 - !ruby/object:Gem::Dependency
   name: dry-validation
   requirement: !ruby/object:Gem::Requirement
@@ -90,7 +84,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '6.0'
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.6
@@ -100,7 +94,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '6.0'
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.6
@@ -167,10 +161,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".env.example"
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -240,7 +236,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Extends light-service with opinionated functionality