foobara 0.0.1

data/projects/persistence/src/entity_attributes_crud_driver.rb

@@ -0,0 +1,241 @@
+module Foobara
+  module Persistence
+    class EntityAttributesCrudDriver
+      attr_accessor :raw_connection, :tables
+
+      def initialize(connection_or_credentials = nil)
+        self.raw_connection = open_connection(connection_or_credentials)
+        self.tables = {}
+      end
+
+      # TODO: audit that this interface is correct
+      def open_connection(_connection_or_credentials)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def open_transaction
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def flush_transaction(_raw_tx)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def revert_transaction(_raw_tx)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def rollback_transaction(_raw_tx)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def close_transaction(_raw_tx)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def table_for(entity_class)
+        key = entity_class.full_entity_name
+
+        tables[key] ||= self.class::Table.new(entity_class, self)
+      end
+
+      # TODO: relocate this to another file?
+      class Table
+        class CannotCrudError < StandardError
+          attr_accessor :record_id
+
+          def verb
+            match = /^Cannot(\w+)Error$/.match(Util.non_full_name(self.class))
+
+            unless match
+              # :nocov:
+              raise "Bad error name for #{self.class.name}"
+              # :nocov:
+            end
+
+            Util.underscore(match[1])
+          end
+
+          def initialize(record_id, submessage = nil)
+            self.record_id = record_id
+            message = "Could not #{verb} for id #{record_id.inspect}"
+
+            if submessage
+              message = "#{message}: #{submessage}"
+            end
+
+            super(message)
+          end
+        end
+
+        class CannotFindError < CannotCrudError; end
+        class CannotInsertError < CannotCrudError; end
+        class CannotUpdateError < CannotCrudError; end
+        class CannotDeleteError < CannotCrudError; end
+
+        attr_accessor :table_name, :entity_class, :raw_connection, :crud_driver
+
+        def initialize(entity_class, crud_driver, table_name = Util.underscore(entity_class.entity_name))
+          self.crud_driver = crud_driver
+          self.entity_class = entity_class
+          # what is this used for?
+          self.raw_connection = crud_driver.raw_connection
+          self.table_name = table_name
+        end
+
+        # CRUD
+        def select(_query_declaration)
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def all
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def first
+          all.first
+        end
+
+        def find(_record_id)
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def find!(_record_id)
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def find_many!(record_ids)
+          record_ids.each.lazy.map do |record_id|
+            find!(record_id)
+          end
+        end
+
+        def find_by_attribute_containing(attribute_name, value)
+          all.find do |found_attributes|
+            found_attributes[attribute_name]&.include?(value)
+          end
+        end
+
+        def find_all_by_attribute_any_of(attribute_name, values)
+          all.select do |attributes|
+            values.include?(attributes[attribute_name])
+          end
+        end
+
+        def find_all_by_attribute_containing_any_of(attribute_name, values)
+          all.select do |attributes|
+            attributes[attribute_name]&.any? do |attribute_value|
+              values.include?(attribute_value)
+            end
+          end
+        end
+
+        def find_by(attributes_filter)
+          all.find do |found_attributes|
+            matches_attributes_filter?(found_attributes, attributes_filter)
+          end
+        end
+
+        def find_many_by(attributes_filter)
+          Enumerator.new do |yielder|
+            all.each do |found_attributes|
+              if matches_attributes_filter?(found_attributes, attributes_filter)
+                yielder << found_attributes
+              end
+            end
+          end
+        end
+
+        def matches_attributes_filter?(attributes, attributes_filter)
+          attributes_filter.all? { |attribute_name, value| attributes[attribute_name] == value }
+        end
+
+        def insert(_attributes)
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def insert_many(attributes_array)
+          # TODO: add a test for a driver that doesn't override this and remove these :nocov: comments
+          # :nocov:
+          attributes_array.each.lazy.map do |attributes|
+            insert(attributes)
+          end
+          # :nocov:
+        end
+
+        def update(_record)
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def hard_delete(_record_id)
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def hard_delete_many(record_ids)
+          # TODO: add a test for a driver that doesn't override this and remove these :nocov: comments
+          # :nocov:
+          record_ids.each.lazy.map do |record_id|
+            delete(record_id)
+          end
+          # :nocov:
+        end
+
+        def hard_delete_all!
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def count
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def exists?(record_id)
+          !!find(record_id)
+        end
+
+        def all_exist?(record_ids)
+          record_ids.all? do |record_id|
+            exists?(record_id)
+          end
+        end
+
+        def record_id_for(attributes)
+          attributes&.[](primary_key_attribute)
+        end
+
+        def primary_key_attribute
+          entity_class.primary_key_attribute
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      class Table
+        attr_accessor :table_name, :entity_base
+
+        def initialize(table_name, entity_base)
+          self.entity_base = entity_base
+          self.table_name = table_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      class Transaction
+        class CurrentTransactionIsClosedError < StandardError; end
+        class NoCurrentTransactionError < StandardError; end
+
+        module Concerns
+          # NOTE: not really a concern...
+          module EntityCallbackHandling
+            class << self
+              def reset_all
+                install!
+              end
+
+              def install!
+                # TODO: do all this in an install! method and make sure Entity.reset_all clears it.
+                Entity.after_dirtied do |record:, **|
+                  transaction = Transaction.open_transaction_for(record)
+
+                  unless transaction
+                    raise NoCurrentTransactionError,
+                          "Cannot modify #{record} because there's no current transaction"
+                  end
+
+                  unless transaction.open?
+                    # :nocov:
+                    raise CurrentTransactionIsClosedError,
+                          "Cannot modify #{record} because current transaction is not open"
+                    # :nocov:
+                  end
+
+                  transaction.updated(record)
+                end
+
+                Entity.after_undirtied do |record:, **|
+                  transaction = Transaction.open_transaction_for(record)
+
+                  unless transaction
+                    # :nocov:
+                    raise NoCurrentTransactionError,
+                          "Cannot modify #{record} because there's no current transaction"
+                    # :nocov:
+                  end
+
+                  unless transaction.open?
+                    # :nocov:
+                    raise CurrentTransactionIsClosedError,
+                          "Cannot modify #{record} because current transaction is not open"
+                    # :nocov:
+                  end
+
+                  transaction.updated(record)
+                end
+
+                Entity.after_hard_deleted do |record:, **|
+                  transaction = Transaction.open_transaction_for(record)
+
+                  unless transaction
+                    # :nocov:
+                    raise NoCurrentTransactionError,
+                          "Cannot modify #{record} because there's no current transaction"
+                    # :nocov:
+                  end
+
+                  unless transaction.open?
+                    # :nocov:
+                    raise CurrentTransactionIsClosedError,
+                          "Cannot modify #{record} because current transaction is not open"
+                    # :nocov:
+                  end
+
+                  transaction.hard_deleted(record)
+                end
+
+                Entity.after_unhard_deleted do |record:, **|
+                  transaction = Transaction.open_transaction_for(record)
+
+                  unless transaction
+                    # :nocov:
+                    raise NoCurrentTransactionError,
+                          "Cannot modify #{record} because there's no current transaction"
+                    # :nocov:
+                  end
+
+                  unless transaction.open?
+                    # :nocov:
+                    raise CurrentTransactionIsClosedError,
+                          "Cannot modify #{record} because current transaction is not open"
+                    # :nocov:
+                  end
+
+                  transaction.unhard_deleted(record)
+                end
+
+                Entity.after_initialized_loaded do |record:, **|
+                  transaction = Persistence.current_transaction(record)
+                  unless transaction
+                    # :nocov:
+                    raise NoCurrentTransactionError,
+                          "Cannot initialize #{record} because there's no current transaction"
+                    # :nocov:
+                  end
+
+                  unless transaction.open?
+                    # :nocov:
+                    raise CurrentTransactionIsClosedError,
+                          "Cannot initialize #{record} because current transaction is not open"
+                    # :nocov:
+                  end
+                  # TODO: we need a way to not blow up here in case of non-block form of transaction
+                  transaction.track_loaded(record)
+                end
+
+                Entity.after_initialized_created do |record:, **|
+                  transaction = Persistence.current_transaction(record)
+                  unless transaction
+                    raise NoCurrentTransactionError,
+                          "Cannot initialize #{record} because there's no current transaction"
+                  end
+
+                  unless transaction.open?
+                    # :nocov:
+                    raise CurrentTransactionIsClosedError,
+                          "Cannot initialize #{record} because current transaction is not open"
+                    # :nocov:
+                  end
+                  # TODO: we need a way to not blow up here in case of non-block form of transaction
+                  transaction.track_created(record)
+                end
+
+                Entity.after_initialized_thunk do |record:, **|
+                  transaction = Persistence.current_transaction(record)
+                  unless transaction
+                    # :nocov:
+                    raise NoCurrentTransactionError,
+                          "Cannot initialize #{record} because there's no current transaction"
+                    # :nocov:
+                  end
+
+                  unless transaction.open?
+                    # :nocov:
+                    raise CurrentTransactionIsClosedError,
+                          "Cannot initialize #{record} because current transaction is not open"
+                    # :nocov:
+                  end
+                  # TODO: we need a way to not blow up here in case of non-block form of transaction
+                  transaction.track_unloaded_thunk(record)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      class Transaction
+        # Used to communicate to enclosing transaction that execution has terminated and the transaction is borked
+        class RolledBack < StandardError; end
+
+        module Concerns
+          module StateTransitions
+            foobara_delegate :close!, :currently_open?, to: :state_machine
+
+            def open!
+              state_machine.open! do
+                self.raw_tx = entity_attributes_crud_driver.open_transaction
+              end
+            end
+
+            def flush!
+              state_machine.flush! do
+                each_table(&:validate!)
+                each_table(&:flush_created!)
+                each_table(&:flush_updated_and_hard_deleted!)
+              end
+            rescue => e
+              # :nocov:
+              rollback!(e)
+              raise
+              # :nocov:
+            end
+
+            # Should communicate somehow that this is only in-memory.
+            # TODO: support multiple-reverts for databases that support checkpoints
+            def revert!
+              state_machine.revert! do
+                each_table(&:revert!)
+              end
+            rescue => e
+              # :nocov:
+              rollback!(e)
+              raise
+              # :nocov:
+            end
+
+            def commit!
+              state_machine.commit! do
+                each_table(&:validate!)
+                each_table(&:flush_created!)
+                each_table(&:flush_updated_and_hard_deleted!)
+                entity_attributes_crud_driver.close_transaction(raw_tx)
+              end
+            rescue => e
+              # :nocov:
+              rollback!(e)
+              raise
+              # :nocov:
+            end
+
+            # TODO: this belongs elsewhere
+            def each_table(&)
+              tables.values.each(&)
+            end
+
+            def rollback!(because_of = nil)
+              state_machine.rollback! do
+                # TODO: raise error if already flushed and if crud_driver doesn't support true transactions
+                entity_attributes_crud_driver.rollback_transaction(raw_tx)
+                each_table(&:rollback!)
+                entity_attributes_crud_driver.close_transaction(raw_tx)
+              end
+
+              if !because_of && (self == entity_base.current_transaction)
+                raise RolledBack, "intentionally rolled back"
+              end
+            rescue
+              state_machine.error! if state_machine.currently_open?
+              raise
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      class Transaction
+        module Concerns
+          module TransactionTracking
+            include Concern
+
+            module ClassMethods
+              def install!
+                Transaction::StateMachine.register_transition_callback(:after,
+                                                                       transition: :open) do |state_machine:, **|
+                  transaction = state_machine.owner
+                  Transaction.open_transactions << transaction
+                end
+
+                Transaction::StateMachine.register_transition_callback(:after, to: :closed) do |state_machine:, **|
+                  transaction = state_machine.owner
+                  Transaction.open_transactions.delete(transaction)
+                end
+              end
+
+              def reset_all
+                @open_transactions = nil
+              end
+
+              def open_transactions
+                @open_transactions ||= Set.new
+              end
+
+              def open_transaction_for(record)
+                # let's check the current_transaction first since that usually will match
+                tx = Persistence.current_transaction(record)
+
+                if tx&.tracking?(record)
+                  return tx
+                else
+                  entity_base = record.class.entity_base
+
+                  tx = open_transactions.find do |transaction|
+                    transaction.entity_base == entity_base && transaction.tracking?(record)
+                  end
+                end
+
+                tx
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      class Transaction
+        class StateMachine < Foobara::StateMachine
+          # TODO: make these outer braces optional somehow
+          set_transition_map({
+                               unopened: {
+                                 open: :open,
+                                 close: :closed
+                               },
+                               open: {
+                                 # TODO: maybe call this something involving "checkpoint"?
+                                 flush: :open,
+                                 revert: :open,
+                                 close: :closed,
+                                 # TODO: should we have intermediate states to quickly get out of the open state?
+                                 rollback: :closed,
+                                 commit: :closed,
+                                 error: :closed
+                               }
+                             })
+        end
+      end
+    end
+  end
+end