foobara 0.0.1

data/projects/persistence/src/entity_base/transaction.rb

@@ -0,0 +1,163 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      class Transaction
+        include Concerns::StateTransitions
+        include Concerns::EntityCallbackHandling
+        include Concerns::TransactionTracking
+
+        attr_accessor :state_machine, :entity_base, :raw_tx, :tables
+
+        def initialize(entity_base)
+          self.entity_base = entity_base
+          self.state_machine = StateMachine.new(owner: self)
+          self.tables = {}
+        end
+
+        foobara_delegate :entity_attributes_crud_driver, to: :entity_base
+
+        def create(entity_class, attributes = {})
+          Persistence.to_base(entity_class).transaction(existing_transaction: self) do
+            entity_class.create(attributes)
+          end
+        end
+
+        def thunk(entity_class, record_id)
+          Persistence.to_base(entity_class).transaction(existing_transaction: self) do
+            entity_class.thunk(record_id)
+          end
+        end
+
+        def loaded(entity_class, attributes)
+          Persistence.to_base(entity_class).transaction(existing_transaction: self) do
+            entity_class.loaded(attributes)
+          end
+        end
+
+        def open?
+          state_machine.currently_open?
+        end
+
+        def closed?
+          state_machine.currently_closed?
+        end
+
+        def loading?(record)
+          table_for(record).loading?(record)
+        end
+
+        def tracking?(record)
+          table_for(record).tracking?(record)
+        end
+
+        def table_for(entity_class)
+          if entity_class.is_a?(Entity)
+            entity_class = entity_class.class
+          end
+
+          # TODO: so much passing self around...
+          unless entity_base == entity_class.entity_base
+            # :nocov:
+            raise "#{entity_class} is from a different entity base! Cannot proceed."
+            # :nocov:
+          end
+
+          tables[entity_class] ||= TransactionTable.new(self, entity_class)
+        end
+
+        def updated(record)
+          table_for(record).updated(record)
+        end
+
+        def hard_deleted(record)
+          table_for(record).hard_deleted(record)
+        end
+
+        def unhard_deleted(record)
+          table_for(record).unhard_deleted(record)
+        end
+
+        def truncate!
+          each_table(&:hard_delete_all!)
+        end
+
+        def hard_delete_all!(entity_class)
+          table_for(entity_class).hard_delete_all!
+        end
+
+        def load(record_or_entity_class, record_id = nil)
+          entity_or_id = if record_or_entity_class.is_a?(Entity)
+                           if record_id
+                             # :nocov:
+                             raise ArgumentError, "Do not give a record_id when also giving a record"
+                             # :nocov:
+                           end
+
+                           record_or_entity_class
+                         else
+                           unless record_id
+                             # :nocov:
+                             raise ArgumentError, "Must give a record_id when passing in an entity class"
+                             # :nocov:
+                           end
+
+                           record_id
+                         end
+
+          table_for(record_or_entity_class).load(entity_or_id)
+        end
+
+        def load_aggregates(to_load_records)
+          to_load = Set.new
+
+          to_load_records.group_by(&:class).each_pair do |entity_class, records|
+            unloaded = records.reject(&:loaded?)
+            entity_class.current_transaction_table.load_many(unloaded)
+
+            associations = entity_class.associations
+
+            records.each do |record|
+              associations.each_key do |data_path|
+                # TODO: is there a more performant way to append an array to a set? probably.
+                Foobara::DataPath.values_at(data_path, record).each do |value|
+                  to_load << value
+                end
+              end
+            end
+          end
+
+          unless to_load.empty?
+            load_aggregates(to_load)
+          end
+
+          to_load_records
+        end
+
+        def load_aggregate(record)
+          load_aggregates([record]).first
+        end
+
+        def track_unloaded_thunk(entity)
+          table_for(entity).track_unloaded_thunk(entity)
+        end
+
+        def track_loaded(entity)
+          table_for(entity).track_loaded(entity)
+        end
+
+        def track_created(entity)
+          table_for(entity).track_created(entity)
+        end
+
+        def created?(record)
+          table_for(record).created?(record)
+        end
+
+        # WARNING! this seems to bypass validations, hmmm....
+        def flush_created_record!(record)
+          table_for(record).flush_created_record!(record)
+        end
+      end
+    end
+  end
+end

data/projects/persistence/src/entity_base/transaction_table/concerns/queries.rb

@@ -0,0 +1,42 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      class TransactionTable
+        module Concerns
+          # If something accesses the crud driver and manipulates records then it belongs in this concern.
+          module Queries
+            # TODO: why is this query method here but the rest are not?
+            def all(&)
+              enumerator = Enumerator.new do |yielder|
+                tracked_records.each do |record|
+                  next if record.hard_deleted?
+
+                  # if the record is not loaded, it could be an unloaded thunk with a primary key to a row that has
+                  # been deleted or maybe never even existed. So just exclude those and let them come from the
+                  # database in the next loop
+                  if created?(record) || record.loaded?
+                    yielder << record
+                  end
+                end
+
+                entity_attributes_crud_driver_table.all.each do |attributes|
+                  attributes = normalize_attributes(attributes)
+                  primary_key = primary_key_for_attributes(attributes)
+                  next if tracked_records.include_key?(primary_key)
+
+                  yielder << entity_class.loaded(attributes)
+                end
+              end
+
+              if block_given?
+                enumerator.each(&)
+              else
+                enumerator.to_a
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/persistence/src/entity_base/transaction_table/concerns/record_tracking.rb

@@ -0,0 +1,134 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      class TransactionTable
+        module Concerns
+          module RecordTracking
+            attr_accessor :tracked_records, :records
+
+            def initialize
+              @records = {}
+              self.tracked_records = WeakObjectSet.new(entity_class.primary_key_attribute)
+              super
+            end
+
+            def loading(record)
+              if loading?(record)
+                # :nocov:
+                raise "Already loading #{record}"
+                # :nocov:
+              end
+
+              begin
+                mark_loading(record)
+                yield
+              ensure
+                unmark_loading(record)
+              end
+
+              record
+            end
+
+            def tracked(record)
+              tracked_records << record
+            end
+
+            def created(record)
+              tracked_records << record
+              mark_created(record)
+            end
+
+            def hard_deleted(record)
+              if record.persisted?
+                mark_hard_deleted(record)
+                unmark_updated(record)
+              else
+                unmark_created(record)
+                tracked_records.delete(record)
+              end
+            end
+
+            def unhard_deleted(record)
+              unmark_hard_deleted(record)
+
+              if record.dirty?
+                mark_updated(record)
+              end
+            end
+
+            def all_hard_deleted
+              tracked_records.clear
+              marked_hard_deleted.clear
+              marked_updated.clear
+              marked_created.clear
+            end
+
+            def updated(record)
+              # Hacky way to handle situation where the primary key might have changed.
+              # TODO: make a better way of handling this.
+              tracked_records.delete(record)
+              tracked_records << record
+
+              # TODO: is this check redundant? Maybe have the entity explode directly instead?
+              if hard_deleted?(record)
+                # :nocov:
+                raise "Cannot update a hard deleted record"
+                # :nocov:
+              end
+
+              unless created?(record)
+                if record.dirty?
+                  mark_updated(record)
+                else
+                  unmark_updated(record)
+                end
+              end
+            end
+
+            def rolled_back
+              marked_hard_deleted.clear
+              marked_updated.clear
+              marked_created.clear
+              tracked_records.clear
+            end
+
+            def reverted
+              marked_hard_deleted.clear
+              marked_updated.clear
+              marked_created.clear
+            end
+
+            interesting_record_states = %i[
+              updated
+              hard_deleted
+              created
+              loading
+            ]
+
+            interesting_record_states.each do |state|
+              define_method "mark_#{state}" do |record|
+                set = records[state] ||= Set.new
+                set << record
+              end
+
+              define_method "unmark_#{state}" do |record|
+                if records.key?(state)
+                  records[state].delete(record)
+                end
+              end
+
+              define_method "#{state}?" do |record|
+                records[state]&.include?(record)
+              end
+
+              # TODO: we should store created_at and updated_at and deleted_at with all of these records...
+              define_method "marked_#{state}" do
+                records[state] ||= Set.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end