light-service-ext 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5af4ef116e875211e34ed7878338e8e6a6e7a4b2b0a1777bcd685a4d33219e18
-  data.tar.gz: 2cbc4827230fa19f43140d0022a75b308ac516b86eab1fc201358a060b3503c6
+  metadata.gz: aad64b8f2360c7b9e4576bcfe6e167f10a87424392b9677ca620b973ba3dc8ef
+  data.tar.gz: 18a7ff6bde7fab9b58eb1e883fbb79cc346be9d98e9516135de3b5e6eabd570c
 SHA512:
-  metadata.gz: 640c9a51e52035660e2e2c56ce3573c5d5cf9586897fb8f6e483e6f32ebe3cc54612170d4f851e06837fe4b155f5dd10ce57f100616270f988dafff50ec227d0
-  data.tar.gz: 1d62d1806e54380ed3a66f54dee065fb76a9d7a91aae12c3191e70544f1c1f1b3e4148f6fa7c787e0b438cc3f96640b002cbcfe323342664fc7b5b7c827eed99
+  metadata.gz: c0f1d41f1530c3b8e9624f0c3ef360464b9a67d8c7e21893b4ecea3db8b09d19b967e7a0dbbc6d66cc1e90677186954c62ab1d734e026ca434b183d7ad3bbdc8
+  data.tar.gz: d81ae82181b451ad2330dc42ccbf33f11cab6b99a0afaa47ba77d4a8bf88bcb6903b486439be926ea408fc2dc06b8e27626843f45a69e6053c9afb4d3dd4f401

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/README.md

@@ -173,12 +173,14 @@ end
   - `LightServiceExt::Status::INCOMPLETE`
 - `:last_failed_context` ~ copy of context that failed e.g. with `errors` field present
 - `internal_only` ~ includes the likes of raised error summary and should never be passed to endpoint responses
+- `meta` ~ used to store any additional information that could be helpful especially for debugging purposes.
 Example
 
 ````ruby
 input = { order: order }
 overrides = {} # optionally override `params`, `errors` and `allow_raise_on_failure`
-LightServiceExt::ApplicationContext.make_with_defaults(input, overrides)
+meta = { current_user_id: 12345, request_id: some-unique-request-id, impersonator_id: 54321 }
+LightServiceExt::ApplicationContext.make_with_defaults(input, overrides, meta: meta)
 
 # => { input: { order: order },
 #      errors: { email: ['not found'] },
@@ -190,7 +192,8 @@ LightServiceExt::ApplicationContext.make_with_defaults(input, overrides)
 #      api_responses: [ { user_id: 1, status: 'ACTIVE' } ],
 #      last_failed_context: {input: { order: order }, params: {}, ...},
 #      allow_raise_on_failure: true,
-#      internal_only: { error_info: ErrorInfoInstance }
+#      internal_only: { error_info: ErrorInfoInstance },
+#     meta: { current_user_id: 12345, request_id: some-unique-request-id, impersonator_id: 54321 }
 #    }
 ````
 

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,8 @@ 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: {},
+          meta: {}
         }.freeze
       end
     end
@@ -61,6 +64,23 @@ module LightServiceExt
       add_attrs_to_ctx(:internal_only, **attrs)
     end
 
+    def add_meta(**attrs)
+      add_attrs_to_ctx(:meta, **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 +97,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/record_actions.rb

@@ -6,14 +6,37 @@ module LightServiceExt
 
     def self.call(context)
       with_error_handler(ctx: context) do
-        result = yield
-        return context if outcomes_complete?(ctx: context, result: result)
+        self.before_execute_block.call(context)
+
+        result = yield || context
+
+        self.after_execute_block.call(context)
+        self.after_success_block.call(context) if result.success?
+        self.after_failure_block.call(context) if result.failure?
 
+        return context if outcomes_complete?(ctx: context, result: result)
         merge_api_responses!(ctx: context, result: result)
       end
     end
 
     class << self
+      attr_writer :before_execute_block, :after_execute_block, :after_success_block, :after_failure_block
+
+      def before_execute_block
+        @before_execute_block ||= ->(_context) {}
+      end
+
+      def after_execute_block
+        @after_execute_block ||= ->(_context) {}
+      end
+
+      def after_success_block
+        @after_success_block ||= ->(_context) {}
+      end
+
+      def after_failure_block
+        @after_failure_block ||= ->(_context) {}
+      end
       def merge_api_responses!(ctx:, result:)
         invoked_action = result.invoked_action
         return if invoked_action.nil?

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LightServiceExt
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 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)
-
+      @result = yield || ctx
+    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

@@ -16,17 +16,17 @@ Gem::Specification.new do |gem|
   gem.name = "light-service-ext"
   gem.require_paths = ["lib"]
   gem.version = LightServiceExt::VERSION
-  gem.required_ruby_version = ">= 3"
+  gem.required_ruby_version = ">= 2.7"
 
   gem.metadata["homepage_uri"] = gem.homepage
   gem.metadata["source_code_uri"] = gem.homepage
   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)
@@ -221,6 +325,21 @@ module LightServiceExt
 
       subject(:ctx_with_defaults) { described_class.make_with_defaults(input, overrides) }
 
+      describe '#add_meta' do
+        it 'adds meta to context' do
+          ctx_with_defaults.add_meta(key => value)
+          expect(ctx_with_defaults.meta).to eql(key => value)
+        end
+      end
+
+      context 'with meta as an override' do
+        let(:overrides) { { meta: { key: 'some-value' } } }
+
+        it 'adds meta to context' do
+          expect(ctx_with_defaults.meta).to eql(key => value)
+        end
+      end
+
       context 'with non symbolized input keys' do
         let(:input) { { "key" => 'some-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/record_actions_spec.rb

@@ -19,6 +19,40 @@ module LightServiceExt
 
       subject(:called_ctx) { described_class.call(ctx, &proc) }
 
+      describe 'lifecycle callbacks' do
+        before do
+          allow(described_class.before_execute_block).to receive(:call)
+          allow(described_class.after_execute_block).to receive(:call)
+          allow(described_class.after_success_block).to receive(:call)
+          allow(described_class.after_failure_block).to receive(:call)
+        end
+
+        it 'calls appropriate lifecycle callbacks' do
+          called_ctx
+
+          expect(described_class.before_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
+          expect(described_class.after_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
+          expect(described_class.after_success_block).to have_received(:call).with(kind_of(ApplicationContext))
+          expect(described_class.after_failure_block).not_to have_received(:call)
+        end
+
+        context 'with failure' do
+          before do
+            allow_any_instance_of(ApplicationContext).to receive(:success?) { false }
+            allow_any_instance_of(ApplicationContext).to receive(:failure?) { true }
+          end
+
+          it 'calls appropriate lifecycle callbacks' do
+            called_ctx
+
+            expect(described_class.before_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
+            expect(described_class.after_execute_block).to have_received(:call).with(kind_of(ApplicationContext))
+            expect(described_class.after_failure_block).to have_received(:call).with(kind_of(ApplicationContext))
+            expect(described_class.after_success_block).not_to have_received(:call)
+          end
+        end
+      end
+
       it 'returns expected context' do
         expect(called_ctx.success?).to be_truthy
         expect(called_ctx.successful_actions).to be_empty

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.10
 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
@@ -233,14 +229,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !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