State projectors moved to the same file where process manager class is defined.

- state projector class is now nested inside each process manager class defintion to emphasize it's a part of the process
- Infra::Process manager with_state definition uses block again to allow state projector class to be defined below

Author: dysk

ecommerce/processes/lib/processes/determine_vat_rates_on_order_placed.rb

@@ -1,8 +1,6 @@
-require_relative 'state_projectors/determine_vat_rates_on_order_placed'
-
 module Processes
   class DetermineVatRatesOnOrderPlaced
-    include Infra::ProcessManager.with_state(StateProjectors::DetermineVatRatesOnOrderPlaced)
+    include Infra::ProcessManager.with_state { StateProjector }
 
     subscribes_to(
       Pricing::OfferAccepted,
@@ -26,5 +24,32 @@ def determine_vat_rates
     def fetch_id(event)
       event.data.fetch(:order_id)
     end
+
+    class StateProjector
+      ProcessState = Data.define(:offer_accepted, :order_placed, :order_id, :order_lines) do
+        def initialize(offer_accepted: false, order_placed: false, order_id: nil, order_lines: [])
+          super
+        end
+
+        def placed? = offer_accepted && order_placed
+      end
+
+      def self.initial_state_instance
+        ProcessState.new
+      end
+
+      def self.apply(state_instance, event)
+        case event
+        when Pricing::OfferAccepted
+          state_instance.with(
+            offer_accepted: true,
+            order_lines: event.data.fetch(:order_lines),
+            order_id: event.data.fetch(:order_id)
+          )
+        when Fulfillment::OrderRegistered
+          state_instance.with(order_placed: true)
+        end
+      end
+    end
   end
 end

ecommerce/processes/lib/processes/order_item_invoicing_process.rb

@@ -1,9 +1,6 @@
-require_relative 'state_projectors/order_item_invoicing_process'
-
 module Processes
   class OrderItemInvoicingProcess
-    include Infra::ProcessManager.with_state(StateProjectors::OrderItemInvoicingProcess)
-
+    include Infra::ProcessManager.with_state { StateProjector }
     subscribes_to(
       Pricing::PriceItemValueCalculated,
       Taxes::VatRateDetermined
@@ -58,4 +55,36 @@ def call
       distributed_amounts
     end
   end
+
+  class StateProjector
+      ProcessState = Data.define(:order_id, :product_id, :quantity, :vat_rate, :discounted_amount) do
+        def initialize(order_id: nil, product_id: nil, quantity: nil, vat_rate: nil, discounted_amount: nil)
+          super
+        end
+
+        def can_create_invoice_item?
+          order_id && product_id && quantity && vat_rate && discounted_amount
+        end
+      end
+
+      def self.initial_state_instance
+        ProcessState.new
+      end
+
+      def self.apply(state_instance, event)
+        case event
+        when Pricing::PriceItemValueCalculated
+          state_instance.with(
+            order_id: event.data.fetch(:order_id),
+            product_id: event.data.fetch(:product_id),
+            quantity: event.data.fetch(:quantity),
+            discounted_amount: event.data.fetch(:discounted_amount)
+          )
+        when Taxes::VatRateDetermined
+          state_instance.with(
+            vat_rate: event.data.fetch(:vat_rate)
+          )
+        end
+      end
+    end
 end

ecommerce/processes/lib/processes/release_payment_process.rb

@@ -1,8 +1,6 @@
-require_relative 'state_projectors/release_payment_process'
-
 module Processes
   class ReleasePaymentProcess
-    include Infra::ProcessManager.with_state(StateProjectors::ReleasePaymentProcess)
+    include Infra::ProcessManager.with_state { StateProjector }
     subscribes_to(
       Payments::PaymentAuthorized,
       Payments::PaymentReleased,
@@ -24,5 +22,39 @@ def release_payment
     def fetch_id(event)
       event.data.fetch(:order_id)
     end
+
+    class StateProjector
+      ProcessState = Data.define(:order, :payment, :order_id) do
+        def initialize(order: :draft, payment: :none, order_id: nil)
+          super
+        end
+
+        def release?
+          payment.eql?(:authorized) && order.eql?(:expired)
+        end
+      end
+
+      def self.initial_state_instance
+        ProcessState.new
+      end
+
+      def self.apply(state_instance, event)
+        case event
+        when Payments::PaymentAuthorized
+          state_instance.with(payment: :authorized)
+        when Payments::PaymentReleased
+          state_instance.with(payment: :released)
+        when Fulfillment::OrderRegistered
+          state_instance.with(
+            order: :placed,
+            order_id: event.data.fetch(:order_id)
+          )
+        when Pricing::OfferExpired
+          state_instance.with(order: :expired)
+        when Fulfillment::OrderConfirmed
+          state_instance.with(order: :confirmed)
+        end
+      end
+    end
   end
 end

ecommerce/processes/lib/processes/reservation_process.rb

@@ -1,8 +1,6 @@
-require_relative 'state_projectors/reservation_process'
-
 module Processes
   class ReservationProcess
-    include Infra::ProcessManager.with_state(StateProjectors::ReservationProcess)
+    include Infra::ProcessManager.with_state { StateProjector }
 
     subscribes_to(
       Pricing::OfferAccepted,
@@ -72,12 +70,34 @@ def fetch_id(event)
       event.data.fetch(:order_id)
     end
 
-    ProcessState = Data.define(:order, :order_lines) do
-      def initialize(order: nil, order_lines: [])
-        super(order:, order_lines: order_lines.freeze)
+    class StateProjector
+      ProcessState = Data.define(:order, :order_lines) do
+        def initialize(order: nil, order_lines: [])
+          super(order: order, order_lines: order_lines.freeze)
+        end
+
+        def reserved_product_ids
+          order_lines.keys
+        end
       end
 
-      def reserved_product_ids = order_lines.keys
+      def self.initial_state_instance
+        ProcessState.new
+      end
+
+      def self.apply(state_instance, event)
+        case event
+        when Pricing::OfferAccepted
+          state_instance.with(
+            order: :accepted,
+            order_lines: event.data.fetch(:order_lines).map { |ol| [ol.fetch(:product_id), ol.fetch(:quantity)] }.to_h
+          )
+        when Fulfillment::OrderCancelled
+          state_instance.with(order: :cancelled)
+        when Fulfillment::OrderConfirmed
+          state_instance.with(order: :confirmed)
+        end
+      end
     end
 
     class SomeInventoryNotAvailable < StandardError
@@ -87,5 +107,6 @@ def initialize(unavailable_products)
         @unavailable_products = unavailable_products
       end
     end
+
   end
 end

ecommerce/processes/lib/processes/shipment_process.rb

@@ -1,8 +1,6 @@
-require_relative 'state_projectors/shipment_process'
-
 module Processes
   class ShipmentProcess
-    include Infra::ProcessManager.with_state(StateProjectors::ShipmentProcess)
+    include Infra::ProcessManager.with_state { StateProjector }
 
     subscribes_to(
       Shipping::ShippingAddressAddedToShipment,
@@ -34,5 +32,26 @@ def authorize_shipment
     def fetch_id(event)
       event.data.fetch(:order_id)
     end
+
+    class StateProjector
+      ProcessState = Data.define(:order, :shipment) do
+        def initialize(order: nil, shipment: nil) = super
+      end
+
+      def self.initial_state_instance
+        ProcessState.new
+      end
+
+      def self.apply(state_instance, event)
+        case event
+        when Shipping::ShippingAddressAddedToShipment
+          state_instance.with(shipment: :address_set)
+        when Fulfillment::OrderRegistered
+          state_instance.with(order: :placed)
+        when Fulfillment::OrderConfirmed
+          state_instance.with(order: :confirmed)
+        end
+      end
+    end
   end
 end