light-service-ext 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a72952c78aab0b82bbce081bd1c2ab955ef264a9fbb5186a9ead3a429eaa504e
-  data.tar.gz: 43cb1863bac420a7150573a0e24cc141bd2384e36cfc4440dbd12f2fce276e93
+  metadata.gz: 962aaba417524bf102f137c7f62dd622b440701dc106c6afa8372bcb4c2c36ec
+  data.tar.gz: 71430081be864aee8f985f67adc936ce46c078a8e19f9e476e4337f5d1d89ca0
 SHA512:
-  metadata.gz: cabc217b43f33aa0771de27613eeecd83f425786e93946ed14d716523814a4af7045d464ae16841b6d3e2db20a8b0f4d780190363ad130bf934c100b962ba1f1
-  data.tar.gz: 5ab3b2151ebb98e80b65a24717a628d7e9f60f206b25c258a05d32e3d57c85e832d99b92905f4883e2d770e9240da85e611771b2497d17f7c87687e670b82838
+  metadata.gz: d05157f2a3b4f92591046ef6a51b5fdd55dc9f8d7eeb3fd314529b71a6981bd71bb1d382c58bdd3c3d8bf71cf46095637682b94c35aad37dc9770fba9caef935
+  data.tar.gz: 52144674f23c819c5680d4ab53d54260b1919abaf2bd46ed3fe05351bf169056981c8c89ce762f1a4ad837605ba96b9ab12dc2ff9d63f51e074525c2ae728cb2

data/.rubocop.yml

@@ -242,3 +242,6 @@ RSpec/FilePath:
 
 RSpec/SubjectStub:
   Enabled: false
+
+RSpec/VerifiedDoubles:
+  Enabled: false

data/CHANGELOG.md

@@ -8,6 +8,15 @@
 
 - Fixing issue with with use of `relative_path` inside of `light-service-ext.gemspec`
 
-## [0.1.2] - YYYY-MM-DD
+## [0.1.2] - 2023-02-24
 
 - Updates `README.md` with detailed information on features provided
+
+## [0.1.3] - 2023-02-25
+
+- Adds `Orchestration` of organizers via `ApplicationOrchestrator` functionality to support calling an organizer(s) inside an orchestrator without polluting the orchestrator context from changes to the called organizer
+- Updates `README.md` with detailed information on features provided
+- Records Actions
+  - adds better error handling
+  - records api_responses to organizer's context from each action filled with `current_api_response`
+  - fails the organizer's context if action returned `errors`

data/README.md

@@ -23,77 +23,9 @@ Or install it yourself as:
 
     $ gem install light-service-ext
 
-## ApplicationContext
-
-> Adds useful defaults to the organizer/orchestrator context
-- `:input` ~> values originally provided to organizer get moved here for better isolation
-- `:params` 
-  - stores values `filtered` and `mapped` from original `input`
-  - outcomes/return values provided by any action that implements `LightServiceExt::ApplicationAction`
-- `:errors`
-  - validation errors processed by `LightServiceExt::ApplicationValidatorAction` [dry-validation](https://github.com/dry-rb/dry-validation) contract
-  - manually added by an action e.g. `{ errors: { email: 'not found' } }`
-- `:successful_actions` ~> provides a list of actions processed mostly useful for debugging purposes
-- `:api_responses` ~> contains a list of external API interactions mostly for recording/debugging purposes
-- `:allow_raise_on_failure` ~> determines whether or not to throw a `RaiseOnContextError` error up the stack in the case of validation errors and/or captured exceptions
-- `:outcome` denotes the current status of the organizer with one of the following flags:
-  - `LightServiceExt::Outcome::COMPLETE`
-
-Example
-
-````ruby
-input = { order: order }
-overrides = {} # optionally override `params`, `errors` and `allow_raise_on_failure`
-LightServiceExt::ApplicationContext.make_with_defaults(input, overrides)
-
-# => { input: { order: order },
-#      params: {}, 
-#      errors: {}, 
-#      successful_actions: [], 
-#      api_responses: [], 
-#      allow_raise_on_failure: true 
-#    }
-````
-
-#### Useful methods
-
-- `.add_params(**params)`
-  - Adds given args to context's `params` field
-  - e.g. `add_params(user_id: 1) # => { params: { user_id: 1 } }`
-- `.add_errors(**errors)`
-  - Adds given args to to context's `errors` field
-  - Fails and returns from current action/organizer's context
-  - e.g. `add_to_errors(email: 'not found') # => { errors: { email: 'not found' } }`
-
-
 ## ApplicationOrganizer
-
 > Adds the following support
 
-### Useful methods
-
-- `.reduce_if_success(<list of actions>)` prevents execution of action/step in the case of context failure or `:errors` present
-- `.with_context(&block)` calls given block with `:ctx` argument
-- `.execute_if` ~> Useful if you want the current `Organizer` to act as a `Orchestrator` and call another organizer
-  - *ONLY* modifies the current organizer/orchestrator's as a result of executing `organizer_or_action_class_or_proc` if manually applied by a given `result_callback` Proc
-  - Executed `steps` do modify the current organizer/orchestrator's context without the need for manual intervention
-  - Arguments:
-    - `condition_block` (required) ~> given block is called with current `context` argument
-    - `organizer_or_action_class_or_proc` (required) ~> only executed if `condition_block` evaluates to `true`
-      - must be one of `ApplicationOrganizer`, `ApplicationAction`, `Proc`
-    - `apply_ctx_transform` (optional)
-      - given block is called prior to `organizer_or_action_class_or_proc` being executed 
-      - e.g. `apply_ctx_transform: -> (context) { context[:params][:user_id] = record(context)&.id }`
-      - returned value gets passed to `organizer_or_action_class_or_proc` call
-    - `result_callback` (optional)
-      - given block is called after `organizer_or_action_class_or_proc` has been executed
-      - Useful in the case where you want to augment the current organizer's context based on the context returned from the `organizer_or_action_class_or_proc` call
-      - e.g. `result_callback: -> (ctx:, result:) { ctx[:params] = result[:params] }`
-        - `ctx:` represents the main `organizer/orchestrator's` context
-        - `result:` represents the context returned from the executed `organizer_or_action_class_or_proc`
-    - `steps` (optional) ~> calls current `organizer/orchestrator's` actions/steps and called once `organizer_or_action_class_or_proc` has been processed
-      - *PLEASE NOTE* called regardless of the result from the `organizer_or_action_class_or_proc` call unless you *manually* fail the current context or add `:errors`
-  
 #### Error Handling
 > Provided by `.with_error_handler`
 
@@ -126,25 +58,64 @@ LightServiceExt::ApplicationContext.make_with_defaults(input, overrides)
 #### Retrieve Record
 > Allows for a block to be defined on an organizer in order to retrieve the model record
 
-Example
+#### Failing The Context
+- Prevents further action's been executed in the following scenarios:
+  - All actions complete determined by organizer's `:outcome` context field set to `LightServiceExt::Outcome::COMPLETE`
+
+#### Example
 
 ```ruby
 class TaxCalculator < LightServiceExt::ApplicationOrganizer
   self.retrieve_record = -> (ctx:) { User.find_by(email: ctx.params[:email]) }
 
-  def self.call(input:)
+  def self.call(input)
+    user = record(ctx: input) # `.record` method executes proc provided to `retrieve_record`
+    input = { user: user }.merge(input)
+    
+    super(input)
+  end
+  
+  def self.steps
+    [TaxValidator, CalcuateTaxAction]
+  end
+end
+```
+
+## ApplicationOrchestrator
+> Useful if you want the current `Organizer` to act as a `Orchestrator` and call another organizer
+
+- *ONLY* modifies the orchestrator context from executing `organizer_steps` if manually applied via `each_organizer_result` Proc
+
+### method overrides
+- `organizer_steps` ~ must be a list of organizers to be called prior to orchestrator's actions
+
+### Example
+
+```ruby
+class TaxCalculatorReport < LightServiceExt::ApplicationOrchestrator
+  self.retrieve_record = -> (ctx:) { User.find_by(email: ctx.params[:email]) }
+
+  def self.call(input)
     user = record(ctx: input) # `.record` method executes proc provided to `retrieve_record`
     input = { user: user }.merge(user: user)
     reduce_with({ input: input }, steps)
+    
+    super(input.merge({ user: user })) do |current_organizer_ctx, orchestrator_ctx:|
+      orchestrator_ctx.add_params(current_organizer_ctx.params.slice(:user_id)) # manually add params from executed organizer(s) 
+    end
+  end
+
+  def organizer_steps
+    [TaxCalculator]
+  end
+
+  def steps
+    [TaxReportAction]
   end
 end
 ```
 
-#### Failing The Context
-- Prevents further action's been executed in the following scenarios:
-  - All actions complete determined by organizer's `:outcome` context field set to `LightServiceExt::Outcome::COMPLETE`
-
-### ApplicationAction
+## ApplicationAction
 
 #### Useful methods
 - TODO
@@ -181,6 +152,71 @@ end
 - `.contract_class` ~> sets the [dry-validation](https://github.com/dry-rb/dry-validation) contract to be applied by the current validator action
 - `.params_mapper_class` ~> sets the mapper class that must implement `.map_from(context)` and return mapped `:input` values
 
+ 
+## ApplicationContext
+
+> Adds useful defaults to the organizer/orchestrator context
+- `:input` ~> values originally provided to organizer get moved here for better isolation
+- `:params` 
+  - stores values `filtered` and `mapped` from original `input`
+  - outcomes/return values provided by any action that implements `LightServiceExt::ApplicationAction`
+- `:errors`
+  - validation errors processed by `LightServiceExt::ApplicationValidatorAction` [dry-validation](https://github.com/dry-rb/dry-validation) contract
+  - manually added by an action e.g. `{ errors: { email: 'not found' } }`
+- `:successful_actions` ~> provides a list of actions processed mostly useful for debugging purposes e.g. `['SomeActionClassName']`
+- `invoked_action` ~> instance of action to being called.
+- `:current_api_response` ~> action issued api response
+- `:api_responses` ~> contains a list of external API interactions mostly for recording/debugging purposes (**internal only**)
+- `:allow_raise_on_failure` ~> determines whether or not to throw a `RaiseOnContextError` error up the stack in the case of validation errors and/or captured exceptions
+- `:status` denotes the current status of the organizer with one of the following flags:
+  - `LightServiceExt::Status::COMPLETE`
+  - `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
+Example
+
+````ruby
+input = { order: order }
+overrides = {} # optionally override `params`, `errors` and `allow_raise_on_failure`
+LightServiceExt::ApplicationContext.make_with_defaults(input, overrides)
+
+# => { input: { order: order },
+#      errors: { email: ['not found'] },
+#      params: { user_id: 1 },
+#      status: Status::INCOMPLETE,
+#      invoked_action: SomeActionInstance,
+#      successful_actions: ['SomeActionClassName'],
+#      current_api_response: { user_id: 1, status: 'ACTIVE' },
+#      api_responses: [ { user_id: 1, status: 'ACTIVE' } ],
+#      last_failed_context: {input: { order: order }, params: {}, ...},
+#      allow_raise_on_failure: true,
+#      internal_only: { error_info: ErrorInfoInstance }
+#    }
+````
+
+#### Useful methods
+- `.add_params(**params)`
+  - Adds given args to context's `params` field
+  - e.g. `add_params(user_id: 1) # => { params: { user_id: 1 } }`
+
+- `add_errors!`
+  - Adds given args to to context's `errors` field
+  - Fails and returns from current action/organizer's context
+  - e.g. `add_to_errors!(email: 'not found') # => { errors: { email: 'not found' } }`
+
+- `.add_errors(**errors)`
+  - Adds given args to to context's `errors` field
+  - DOES NOT fails current context
+  - e.g. `add_to_errors(email: 'not found') # => { errors: { email: 'not found' } }`
+
+- `.add_status(status)`
+  - Should be one of Statuses e.g. `Status::COMPLETE` 
+  - e.g. `add_status(Status::COMPLETE) # => { status: Status::COMPLETE }`
+
+- `.add_internal_only(attrs)`
+  - e.g. `add_internal_only(request_id: 54) # => { internal_only: { error_info: nil, request_id: 54 }  }`
+- `add_to_successful_actions(action_name_or_names)` ~> adds action names successfully executed
+
 ## ContextError
 
 > Provides all the information related to an exception/validation errors captured by the current organizer

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

@@ -9,7 +9,7 @@ module LightServiceExt
 
       raise ContextError.new(ctx: context) if raise_error
 
-      context[:outcome] = Outcome::COMPLETE
+      context.add_status(Status::COMPLETE)
     end
   end
 end

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

@@ -2,40 +2,38 @@
 
 module LightServiceExt
   class ApplicationContext < LightService::Context
-    OVERRIDABLE_DEFAULT_KEYS = %i[errors params allow_raise_on_failure].freeze
-
     class << self
       def make_with_defaults(input = {}, overrides = {})
-        allowed_overrides = overrides.slice(*OVERRIDABLE_DEFAULT_KEYS)
-        make({ input: input.symbolize_keys }.merge(default_attrs, allowed_overrides))
+        defaults = default_attrs
+        allowed_override_keys = defaults.keys.excluding(:input)
+        allowed_overrides = overrides.slice(*allowed_override_keys)
+        make({ input: input.symbolize_keys }.merge(defaults, allowed_overrides))
       end
 
       private
 
       def default_attrs
-        { errors: {}, params: {}, successful_actions: [], api_responses: [],
+        {
+          errors: {},
+          params: {},
+          status: Status::INCOMPLETE,
+          invoked_action: nil,
+          successful_actions: [],
+          current_api_response: nil,
+          api_responses: [],
+          last_failed_context: nil,
           allow_raise_on_failure: LightServiceExt.config.allow_raise_on_failure?,
-          internal_only: { error_info: nil } }.freeze
+          internal_only: { error_info: nil }
+        }.freeze
       end
     end
 
     def add_params(**params)
-      return if params.blank?
-
-      self[:params].merge!(params.dup)
-    end
-
-    def add_internal_only(**attrs)
-      return if attrs.blank?
-
-      self[:internal_only].merge!(attrs.dup)
+      add_attrs_to_ctx(:params, params)
     end
 
     def add_errors(**errors)
-      return if errors.blank?
-
-      self[:errors].merge!(errors.dup)
-      nil
+      add_attrs_to_ctx(:errors, errors)
     end
 
     def add_errors!(**errors)
@@ -45,12 +43,34 @@ module LightServiceExt
       fail_and_return!
     end
 
-    def invoked_action
-      self[:invoked_action]
+    def add_status(status)
+      add_value_to_ctx(:status, status)
+    end
+
+    def add_current_api_response(api_response)
+      add_value_to_ctx(:current_api_response, api_response)
+    end
+
+    def add_last_failed_context(failed_context)
+      return if failed_context.nil? || failed_context.try(:success?)
+
+      add_value_to_ctx(:last_failed_context, failed_context)
+    end
+
+    def add_internal_only(**attrs)
+      add_attrs_to_ctx(:internal_only, **attrs)
     end
 
-    def validation_errors
-      self[:errors]
+    def add_to_api_responses(*api_response)
+      add_collection_to_ctx(:api_responses, *api_response)
+    end
+
+    def add_to_successful_actions(*action_name)
+      add_collection_to_ctx(:successful_actions, *action_name)
+    end
+
+    def add_invoked_action(invoked_action)
+      add_value_to_ctx(:invoked_action, invoked_action)
     end
 
     def allow_raise_on_failure?
@@ -66,5 +86,26 @@ module LightServiceExt
     def respond_to_missing?(method_name, include_private = false)
       key?(method_name) || super
     end
+
+    private
+
+    def add_value_to_ctx(key, value)
+      self[key] = value
+      nil
+    end
+
+    def add_attrs_to_ctx(key, **attrs)
+      return if attrs.blank?
+
+      self[key].merge!(attrs)
+      nil
+    end
+
+    def add_collection_to_ctx(key, *values)
+      return if values.empty?
+
+      self[key] = self[key].concat(values).compact
+      nil
+    end
   end
 end

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

@@ -0,0 +1,32 @@
+module LightServiceExt
+  class ApplicationOrchestrator < ApplicationOrganizer
+    class << self
+      def call(context, &each_organizer_result)
+        orchestrator_ctx = process_each_organizer(ApplicationContext.make_with_defaults(context),
+                                                  &each_organizer_result)
+        with(orchestrator_ctx).around_each(RecordActions).reduce(all_steps)
+      end
+
+      def organizer_steps
+        raise NotImplementedError
+      end
+
+      def process_each_organizer(orchestrator_ctx, &each_organizer_result)
+        organizer_steps.each do |step_class|
+          exec_method = exec_method_for(step_class)
+          current_organizer_ctx = step_class.send(exec_method, orchestrator_ctx.input)
+          yield(current_organizer_ctx, orchestrator_ctx: orchestrator_ctx) if each_organizer_result
+        end
+        orchestrator_ctx
+      end
+
+      private
+
+      def exec_method_for(klass)
+        return :call if klass.is_a?(LightService::Organizer) || klass.is_a?(Proc)
+
+        :execute
+      end
+    end
+  end
+end

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

@@ -4,12 +4,28 @@ module LightServiceExt
   class ApplicationOrganizer
     extend LightService::Organizer
 
-    def self.call(context)
-      with(ApplicationContext.make_with_defaults(context)).reduce(steps)
-    end
+    class << self
+      def call(context)
+        with(ApplicationContext.make_with_defaults(context))
+          .around_each(RecordActions)
+          .reduce(all_steps)
+      end
+
+      def steps
+        raise NotImplementedError
+      end
+
+      def reduce_if_success(steps)
+        reduce_if(->(ctx) { ctx.success? && ctx[:errors].blank? }, steps)
+      end
+
+      private
+
+      def all_steps
+        return steps.push(AllActionsCompleteAction) if steps.is_a?(Array)
 
-    def self.steps
-      raise NotImplementedError
+        [steps].push(AllActionsCompleteAction)
+      end
     end
   end
 end

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

@@ -8,7 +8,7 @@ module LightServiceExt
     executed do |context|
       validator = map_and_validate_inputs(context)
       context.add_params(**validator.to_h)
-      context.add_errors!(**validator.errors.to_h.transform_values(&:first))
+      context.add_errors!(**validator.errors.to_h)
     end
 
     class << self

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

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module LightServiceExt
-  module Outcome
+  module Status
     COMPLETE = :all_steps_complete
+    INCOMPLETE = :steps_incomplete
   end
 end

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

@@ -31,7 +31,7 @@ module LightServiceExt
 
     def errors
       model = error && (error.try(:model) || error.try(:record))
-      return model.errors.messages.transform_values(&:first) if model.present?
+      return model.errors.messages if model.present?
 
       { base: message }
     end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module LightServiceExt
+  class RecordActions
+    extend WithErrorHandler
+
+    def self.call(context)
+      with_error_handler(ctx: context) do
+        result = yield
+        return context if outcomes_complete?(ctx: context, result: result)
+
+        merge_api_responses!(ctx: context, result: result)
+      end
+    end
+
+    class << self
+      def merge_api_responses!(ctx:, result:)
+        invoked_action = result.invoked_action
+        return if invoked_action.nil?
+
+        ctx.add_to_successful_actions(invoked_action.name)
+        ctx.add_to_api_responses(result.current_api_response)
+        ctx
+      end
+
+      def outcomes_complete?(ctx:, result:)
+        if result.status == Status::COMPLETE
+          ctx.add_status(result.status)
+
+          if ctx.errors.present?
+            ctx.add_last_failed_context(result.to_h)
+            ctx.fail!
+          end
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

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

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

data/lib/light-service-ext.rb

@@ -8,6 +8,7 @@ error_info
 context_error
 configuration
 with_error_handler
+record_actions
 application_context
 application_contract
 around_action_execute_extension
@@ -15,6 +16,7 @@ application_action
 all_actions_complete_action
 application_validator_action
 application_organizer
+application_orchestrator
 ].each do |filename|
   require File.expand_path("../light-service-ext/#{filename}", Pathname.new(__FILE__).realpath)
 end

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

@@ -23,7 +23,7 @@ module LightServiceExt
       it 'does not raise error' do
         expect { executed_ctx }.not_to raise_error
 
-        expect(executed_ctx.keys).to include(:outcome)
+        expect(executed_ctx.keys).to include(:status)
       end
 
       context 'with raising of errors allowed' do

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

@@ -7,6 +7,102 @@ module LightServiceExt
 
     subject(:ctx) { described_class.make_with_defaults(input) }
 
+    describe '#add_to_successful_actions' do
+      it 'adds successful action name to context' do
+        ctx.add_to_successful_actions(value)
+
+        expect(ctx.successful_actions).to match_array([value])
+      end
+
+      it 'preserves other successful action name' do
+        ctx.add_to_successful_actions(value)
+
+        ctx.add_to_successful_actions('other-value')
+
+        expect(ctx.successful_actions).to match_array([value, 'other-value'])
+      end
+    end
+
+    describe '#add_to_api_responses' do
+      it 'adds last api response to context' do
+        ctx.add_to_api_responses(value)
+
+        expect(ctx.api_responses).to match_array([value])
+      end
+
+      it 'preserves other api responses' do
+        ctx.add_to_api_responses(value)
+
+        ctx.add_to_api_responses('other-value')
+
+        expect(ctx.api_responses).to match_array([value, 'other-value'])
+      end
+    end
+
+    describe '#add_last_failed_context' do
+      it 'adds last failed context' do
+        ctx.add_last_failed_context(value)
+
+        expect(ctx.last_failed_context).to eql(value)
+      end
+
+      it 'updates older values' do
+        ctx.add_last_failed_context(value)
+
+        ctx.add_last_failed_context('other-value')
+
+        expect(ctx.last_failed_context).to eql('other-value')
+      end
+    end
+
+    describe '#add_status' do
+      it 'adds current api response to context' do
+        ctx.add_status(value)
+
+        expect(ctx.status).to eql(value)
+      end
+
+      it 'updates older values' do
+        ctx.add_status(value)
+
+        ctx.add_status('other-value')
+
+        expect(ctx.status).to eql('other-value')
+      end
+    end
+
+    describe '#add_current_api_response' do
+      it 'adds current api response to context' do
+        ctx.add_current_api_response(value)
+
+        expect(ctx.current_api_response).to eql(value)
+      end
+
+      it 'updates older values' do
+        ctx.add_current_api_response(value)
+
+        ctx.add_current_api_response('other-value')
+
+        expect(ctx.current_api_response).to eql('other-value')
+      end
+    end
+
+    describe '#add_invoked_action' do
+      it 'adds last api response to context' do
+        ctx.add_invoked_action(value)
+
+        expect(ctx.invoked_action).to eql(value)
+      end
+
+      it 'updates older values' do
+        ctx.add_invoked_action(value)
+
+        ctx.add_invoked_action('other-value')
+
+        expect(ctx.invoked_action).to eql('other-value')
+      end
+    end
+
     describe '#add_errors!' do
       before { allow(ctx).to receive(:fail_and_return!) }
 
@@ -134,13 +230,19 @@ module LightServiceExt
       end
 
       it 'returns context with default attrs' do
-        expect(ctx_with_defaults.keys).to match_array(%i[input
-                                                         errors
-                                                         params
-                                                         successful_actions
-                                                         api_responses
-                                                         allow_raise_on_failure
-                                                         internal_only])
+        expect(ctx_with_defaults.keys).to match_array(%i[
+                                                        input
+                                                        params
+                                                        errors
+                                                        status
+                                                        successful_actions
+                                                        allow_raise_on_failure
+                                                        api_responses
+                                                        internal_only
+                                                        invoked_action
+                                                        current_api_response
+                                                        last_failed_context
+                                                      ])
 
         expect(ctx_with_defaults[:input]).to eql(input)
       end
@@ -160,8 +262,8 @@ module LightServiceExt
             described_class.make_with_defaults(input, successful_actions: ['some-action-class-name'])
           end
 
-          it 'prevents successful_actions to change from default' do
-            expect(ctx_with_defaults[:successful_actions]).to be_empty
+          it 'allows for overrides' do
+            expect(ctx_with_defaults[:successful_actions]).to match_array(['some-action-class-name'])
           end
         end
 
@@ -170,8 +272,8 @@ module LightServiceExt
             described_class.make_with_defaults(input, api_responses: ['some-api-response'])
           end
 
-          it 'prevents successful_actions to change from default' do
-            expect(ctx_with_defaults[:api_responses]).to be_empty
+          it 'allows for overrides' do
+            expect(ctx_with_defaults[:api_responses]).to match_array(['some-api-response'])
           end
         end
 

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

@@ -0,0 +1,76 @@
+module LightServiceExt
+  RSpec.describe ApplicationOrchestrator do
+    describe '.call' do
+      let(:orchestrator_class) do
+        FakeOrganizer = Class.new(ApplicationOrganizer) do
+          class << self
+            FakeOrganizerAction = Class.new do
+              extend LightService::Action
+
+              expects :input
+
+              executed do |context|
+                context.dig(:input, :organizer_action_proc).call(context)
+              end
+            end
+
+            def steps
+              [FakeOrganizerAction]
+            end
+          end
+        end
+
+        Class.new(described_class) do
+          class << self
+            FakeOrchestratorAction = Class.new do
+              extend LightService::Action
+
+              expects :input
+
+              executed do |context|
+                context.dig(:input, :orchestrator_action_proc).call(context)
+              end
+            end
+
+            def organizer_steps
+              [FakeOrganizer]
+            end
+
+            def steps
+              [FakeOrchestratorAction]
+            end
+          end
+        end
+      end
+
+      let(:input) do
+        { organizer_action_proc: ->(context) { context.add_params(x1: 'x1') },
+          orchestrator_action_proc: ->(context) { context.add_params(x2: 'x2') } }
+      end
+
+      it 'adds orchestrator params without organizer params' do
+        ctx = orchestrator_class.call(input)
+
+        expect(ctx.keys).to include(:input)
+        expect(ctx[:input]).to eql(input)
+        expect(ctx[:params]).to eql(x2: 'x2')
+      end
+
+      context 'with each organizer block' do
+        let(:organizer_block) do
+          lambda { |organizer_ctx, orchestrator_ctx:|
+            orchestrator_ctx.add_params(x3: organizer_ctx.params[:x1])
+          }
+        end
+
+        it 'adds organizer param to orchestrator' do
+          orchestrator_ctx = orchestrator_class.call(input, &organizer_block)
+
+          expect(orchestrator_ctx.keys).to include(:input)
+          expect(orchestrator_ctx[:input]).to eql(input)
+          expect(orchestrator_ctx[:params]).to include(x2: 'x2', x3: 'x1')
+        end
+      end
+    end
+  end
+end

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

@@ -27,15 +27,7 @@ module LightServiceExt
     it 'adds inputted data as input key value pair' do
       ctx = subject_class.call(input)
 
-      expect(ctx.keys).to match_array(%i[
-                                        api_responses
-                                        errors
-                                        input
-                                        params
-                                        allow_raise_on_failure
-                                        successful_actions
-                                        internal_only
-                                      ])
+      expect(ctx.keys).to include(:input)
       expect(ctx[:input]).to eql(input)
     end
 

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

@@ -27,7 +27,7 @@ module LightServiceExt
 
       it 'returns promised params and filled in errors' do
         expect(context).to be_failure
-        expect(context.errors).to eql(key: 'must be filled')
+        expect(context.errors).to eql(key: ['must be filled'])
       end
     end
   end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module LightServiceExt
+  RSpec.describe RecordActions do
+    describe '.call' do
+      let(:input) { {} }
+      let(:action_name) { 'some-action-name' }
+      let(:current_api_response) { nil }
+      let(:invoked_action) { nil }
+      let(:status) { nil }
+      let(:errors) { {} }
+      let(:overrides) { { errors: errors } }
+      let(:ctx) { ApplicationContext.make_with_defaults(input, overrides) }
+      let(:result_ctx_overrides) do
+        { status: status, errors: errors, invoked_action: invoked_action, current_api_response: current_api_response }
+      end
+      let(:result_ctx) { ApplicationContext.make_with_defaults(input, result_ctx_overrides) }
+      let(:proc) { -> { result_ctx } }
+
+      subject(:called_ctx) { described_class.call(ctx, &proc) }
+
+      it 'returns expected context' do
+        expect(called_ctx.success?).to be_truthy
+        expect(called_ctx.successful_actions).to match_array([])
+        expect(called_ctx.api_responses).to match_array([])
+        expect(called_ctx.status).to eql(Status::INCOMPLETE)
+        expect(called_ctx[:last_failed_context]).to be_nil
+      end
+
+      context 'with api response attrs' do
+        let(:invoked_action) { class_double(ApplicationAction, name: action_name) }
+        let(:current_api_response) { 'some-api-response' }
+
+        it 'adds api_response as last api response' do
+          expect(called_ctx.success?).to be_truthy
+          expect(called_ctx.successful_actions).to match_array([action_name])
+          expect(called_ctx.api_responses).to match_array([current_api_response])
+          expect(called_ctx.status).to eql(Status::INCOMPLETE)
+          expect(called_ctx[:last_failed_context]).to be_nil
+        end
+
+        context 'with completed status' do
+          let(:status) { :all_steps_complete }
+
+          it 'adds errors and last failed context' do
+            expect(called_ctx.success?).to be_truthy
+            expect(called_ctx.successful_actions).to be_empty
+            expect(called_ctx.api_responses).to be_empty
+            expect(called_ctx.status).to eql(status)
+            expect(called_ctx[:last_failed_context]).to be_nil
+          end
+
+          context 'with errors' do
+            let(:errors) { { base: 'some-message' } }
+
+            it 'adds last failed context and fails the context' do
+              expect(called_ctx.success?).to be_falsey
+              expect(called_ctx.successful_actions).to be_empty
+              expect(called_ctx.api_responses).to be_empty
+              expect(called_ctx.status).to eql(status)
+              expect(called_ctx[:last_failed_context]).to be_present
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,33 +1,13 @@
 module LightServiceExt
   RSpec.describe WithErrorHandler do
-    unless defined? Rails
-      module Rails
-      end
-    end
-
-    unless defined? Rails::ActiveRecordError
-      module Rails
-        class ActiveRecordError < StandardError
-          def model; end
-        end
-      end
-    end
-
     let(:implementor_class) do
       Class.new do
         extend WithErrorHandler
       end
     end
 
-    let(:key) { :key }
-    let(:key_error) { 'invalid' }
-    let(:messages) { { key => [key_error] } }
     let(:error_message) { 'some-error' }
-    let(:errors) { OpenStruct.new(messages: messages) }
-    let(:model) { OpenStruct.new(errors: errors) }
-    let(:results_ctx_proc) { -> { ApplicationContext.make_with_defaults } }
     let(:ctx) { ApplicationContext.make_with_defaults }
-    let(:error) { Rails::ActiveRecordError.new(error_message) }
 
     before { allow(LightServiceExt.config.logger).to receive(:error) }
 
@@ -36,7 +16,23 @@ module LightServiceExt
         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 } }
+
+        it 'logs errors' do
+          expect { errors_handled_ctx }.to raise_error ArgumentError, error_message
+          expect(LightServiceExt.config.logger).to have_received(:error)
+        end
+      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
@@ -44,7 +40,7 @@ module LightServiceExt
 
           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.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

data/spec/spec_helper.rb

@@ -5,6 +5,19 @@ require Pathname.new(__dir__).realpath.join('coverage_helper').to_s
 
 require 'light-service/testing'
 
+unless defined? Rails
+  module Rails
+  end
+end
+
+unless defined? Rails::ActiveRecordError
+  module Rails
+    class ActiveRecordError < StandardError
+      def model; end
+    end
+  end
+end
+
 RSpec.configure do |config|
   config.before do
     # rubocop:disable Style/ClassVars

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light-service-ext
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Desmond O'Leary
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-24 00:00:00.000000000 Z
+date: 2023-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: light-service
@@ -175,6 +175,7 @@ files:
 - lib/light-service-ext/application_action.rb
 - lib/light-service-ext/application_context.rb
 - lib/light-service-ext/application_contract.rb
+- lib/light-service-ext/application_orchestrator.rb
 - lib/light-service-ext/application_organizer.rb
 - lib/light-service-ext/application_validator_action.rb
 - lib/light-service-ext/around_action_execute_extension.rb
@@ -182,6 +183,7 @@ files:
 - lib/light-service-ext/constants.rb
 - lib/light-service-ext/context_error.rb
 - lib/light-service-ext/error_info.rb
+- lib/light-service-ext/record_actions.rb
 - lib/light-service-ext/regex.rb
 - lib/light-service-ext/version.rb
 - lib/light-service-ext/with_error_handler.rb
@@ -192,12 +194,14 @@ files:
 - spec/light-service-ext/application_action_spec.rb
 - spec/light-service-ext/application_context_spec.rb
 - spec/light-service-ext/application_contract_spec.rb
+- spec/light-service-ext/application_orchestrator_spec.rb
 - spec/light-service-ext/application_organizer_spec.rb
 - spec/light-service-ext/application_validator_action_spec.rb
 - spec/light-service-ext/around_action_execute_extension_spec.rb
 - spec/light-service-ext/configuration_spec.rb
 - spec/light-service-ext/context_error_spec.rb
 - spec/light-service-ext/error_info_spec.rb
+- spec/light-service-ext/record_actions_spec.rb
 - spec/light-service-ext/regex_spec.rb
 - spec/light-service-ext/with_error_handler_spec.rb
 - spec/light_service_ext_spec.rb
@@ -234,12 +238,14 @@ test_files:
 - spec/light-service-ext/application_action_spec.rb
 - spec/light-service-ext/application_context_spec.rb
 - spec/light-service-ext/application_contract_spec.rb
+- spec/light-service-ext/application_orchestrator_spec.rb
 - spec/light-service-ext/application_organizer_spec.rb
 - spec/light-service-ext/application_validator_action_spec.rb
 - spec/light-service-ext/around_action_execute_extension_spec.rb
 - spec/light-service-ext/configuration_spec.rb
 - spec/light-service-ext/context_error_spec.rb
 - spec/light-service-ext/error_info_spec.rb
+- spec/light-service-ext/record_actions_spec.rb
 - spec/light-service-ext/regex_spec.rb
 - spec/light-service-ext/with_error_handler_spec.rb
 - spec/light_service_ext_spec.rb