vorpal 1.0.2 → 1.3.0

data/lib/vorpal/config/foreign_key_info.rb

@@ -0,0 +1,23 @@
+require 'equalizer'
+
+module Vorpal
+  module Config
+    # @private
+    class ForeignKeyInfo
+      include Equalizer.new(:fk_column, :fk_type_column, :fk_type)
+
+      attr_reader :fk_column, :fk_type_column, :fk_type, :polymorphic
+
+      def initialize(fk_column, fk_type_column, fk_type, polymorphic)
+        @fk_column = fk_column
+        @fk_type_column = fk_type_column
+        @fk_type = fk_type
+        @polymorphic = polymorphic
+      end
+
+      def polymorphic?
+        @polymorphic
+      end
+    end
+  end
+end

data/lib/vorpal/config/has_many_config.rb

@@ -0,0 +1,38 @@
+require 'vorpal/config/configs'
+
+module Vorpal
+  module Config
+    # @private
+    # Object association terminology:
+    # - All object associations are uni-directional
+    # - The end that holds the association is the 'Owner' and the end that
+    #   is referred to is the 'Associate' or 'Associates'
+    #
+    # Relational association terminology:
+    # - Local end: has FK
+    # - Remote end: has no FK
+    #
+    class HasManyConfig
+      include Util::HashInitialization
+      include RemoteEndConfig
+
+      attr_reader :name, :owned, :fk, :fk_type, :associated_class, :unique_key_name
+      attr_accessor :association_config
+
+      def get_associated(owner)
+        owner.send(name)
+      end
+
+      def associate(owner, associates)
+        if get_associated(owner).nil?
+          owner.send("#{name}=", [])
+        end
+        get_associated(owner) << associates
+      end
+
+      def pretty_name
+        "#{@class_config.domain_class.name} has_many :#{name}"
+      end
+    end
+  end
+end

data/lib/vorpal/config/has_one_config.rb

@@ -0,0 +1,35 @@
+require 'vorpal/config/configs'
+
+module Vorpal
+  module Config
+    # @private
+    # Object association terminology:
+    # - All object associations are uni-directional
+    # - The end that holds the association is the 'Owner' and the end that
+    #   is referred to is the 'Associate' or 'Associates'
+    #
+    # Relational association terminology:
+    # - Local end: has FK
+    # - Remote end: has no FK
+    #
+    class HasOneConfig
+      include Util::HashInitialization
+      include RemoteEndConfig
+
+      attr_reader :name, :owned, :fk, :fk_type, :associated_class, :unique_key_name
+      attr_accessor :association_config
+
+      def get_associated(owner)
+        owner.send(name)
+      end
+
+      def associate(owner, associate)
+        owner.send("#{name}=", associate)
+      end
+
+      def pretty_name
+        "#{@class_config.domain_class.name} has_one :#{name}"
+      end
+    end
+  end
+end

data/lib/vorpal/config/main_config.rb

@@ -0,0 +1,68 @@
+require 'vorpal/exceptions'
+require 'vorpal/config/association_config'
+
+module Vorpal
+  module Config
+    # @private
+    class MainConfig
+      def initialize
+        @class_configs = []
+      end
+
+      def config_for(clazz)
+        config = @class_configs.detect { |conf| conf.domain_class == clazz }
+        raise Vorpal::ConfigurationNotFound.new("No configuration found for #{clazz}") unless config
+        config
+      end
+
+      def config_for_db_object(db_object)
+        @class_configs.detect { |conf| conf.db_class == db_object.class }
+      end
+
+      def add_class_config(class_config)
+        @class_configs << class_config
+      end
+
+      def initialize_association_configs
+        association_configs = {}
+        @class_configs.each do |config|
+          (config.has_ones + config.has_manys).each do |association_end_config|
+            associated_class_config = config_for(association_end_config.associated_class)
+            association_end_config.set_class_config(config)
+
+            association_config = build_association_config(association_configs, associated_class_config, association_end_config.fk, association_end_config.fk_type)
+            association_config.remote_end_config = association_end_config
+            association_config.add_remote_class_config(config)
+            association_end_config.association_config = association_config
+          end
+
+          config.belongs_tos.each do |association_end_config|
+            associated_class_configs = association_end_config.associated_classes.map(&method(:config_for))
+
+            association_config = build_association_config(association_configs, config, association_end_config.fk, association_end_config.fk_type)
+            association_config.local_end_config = association_end_config
+            association_config.add_remote_class_config(associated_class_configs)
+            association_end_config.association_config = association_config
+          end
+        end
+
+        association_configs.values.each do |association_config|
+          association_config.local_class_config.local_association_configs << association_config
+          association_config.validate
+        end
+      end
+
+      private
+
+      def build_association_config(association_configs, local_config, fk, fk_type)
+        association_config = AssociationConfig.new(local_config, fk, fk_type)
+        if association_configs[association_config]
+          association_config = association_configs[association_config]
+        else
+          association_configs[association_config] = association_config
+        end
+        association_config
+      end
+    end
+  end
+end

data/lib/vorpal/db_loader.rb

@@ -12,7 +12,7 @@ module Vorpal
     end
 
     def load_from_db(ids, config)
-      db_roots = @db_driver.load_by_id(config.db_class, ids)
+      db_roots = @db_driver.load_by_unique_key(config.db_class, ids, "id")
       load_from_db_objects(db_roots, config)
     end
 
@@ -24,9 +24,9 @@ module Vorpal
 
       until @lookup_instructions.empty?
         lookup = @lookup_instructions.next_lookup
-        new_objects = lookup.load_all(@db_driver)
-        @loaded_objects.add(lookup.config, new_objects)
-        explore_objects(lookup.config, new_objects)
+        newly_loaded_objects = lookup.load_all(@db_driver)
+        unexplored_objects = @loaded_objects.add(lookup.config, newly_loaded_objects)
+        explore_objects(lookup.config, unexplored_objects)
       end
 
       @loaded_objects
@@ -55,34 +55,34 @@ module Vorpal
     end
 
     def lookup_by_id(db_object, belongs_to_config)
-      child_config = belongs_to_config.child_config(db_object)
-      id = belongs_to_config.fk_value(db_object)
-      return if id.nil? || @loaded_objects.already_loaded?(child_config, id)
-      @lookup_instructions.lookup_by_id(child_config, id)
+      associated_class_config = belongs_to_config.associated_class_config(db_object)
+      unique_key_value = belongs_to_config.fk_value(db_object)
+      unique_key_name = belongs_to_config.unique_key_name
+      return if unique_key_value.nil? || @loaded_objects.already_loaded_by_unique_key?(associated_class_config, unique_key_name, unique_key_value)
+      @lookup_instructions.lookup_by_unique_key(associated_class_config, unique_key_name, unique_key_value)
     end
 
     def lookup_by_fk(db_object, has_some_config)
-      child_config = has_some_config.child_config
+      associated_class_config = has_some_config.associated_class_config
       fk_info = has_some_config.foreign_key_info
-      fk_value = db_object.id
-      @lookup_instructions.lookup_by_fk(child_config, fk_info, fk_value)
+      fk_value = has_some_config.get_unique_key_value(db_object)
+      @lookup_instructions.lookup_by_fk(associated_class_config, fk_info, fk_value)
     end
   end
 
   # @private
   class LookupInstructions
-    include Util::ArrayHash
     def initialize
-      @lookup_by_id = {}
-      @lookup_by_fk = {}
+      @lookup_by_id = Util::ArrayHash.new
+      @lookup_by_fk = Util::ArrayHash.new
     end
 
-    def lookup_by_id(config, ids)
-      add_to_hash(@lookup_by_id, config, Array(ids))
+    def lookup_by_unique_key(config, column_name, values)
+      @lookup_by_id.append([config, column_name], values)
     end
 
     def lookup_by_fk(config, fk_info, fk_value)
-      add_to_hash(@lookup_by_fk, [config, fk_info], fk_value)
+      @lookup_by_fk.append([config, fk_info], fk_value)
     end
 
     def next_lookup
@@ -100,12 +100,14 @@ module Vorpal
     private
 
     def pop_id_lookup
-      config, ids = pop(@lookup_by_id)
-      LookupById.new(config, ids)
+      key, ids = @lookup_by_id.pop
+      config = key.first
+      column_name = key.last
+      LookupById.new(config, column_name, ids)
     end
 
     def pop_fk_lookup
-      key, fk_values = pop(@lookup_by_fk)
+      key, fk_values = @lookup_by_fk.pop
       config = key.first
       fk_info = key.last
       LookupByFk.new(config, fk_info, fk_values)
@@ -115,14 +117,15 @@ module Vorpal
   # @private
   class LookupById
     attr_reader :config
-    def initialize(config, ids)
+    def initialize(config, column_name, ids)
       @config = config
+      @column_name = column_name
       @ids = ids
     end
 
     def load_all(db_driver)
       return [] if @ids.empty?
-      db_driver.load_by_id(@config.db_class, @ids)
+      db_driver.load_by_unique_key(@config.db_class, @ids, @column_name)
     end
   end
 

data/lib/vorpal/driver/postgresql.rb

@@ -9,7 +9,12 @@ module Vorpal
       end
 
       def insert(db_class, db_objects)
-        if defined? ActiveRecord::Import
+        if ActiveRecord::VERSION::MAJOR >= 6
+          return if db_objects.empty?
+
+          update_timestamps_on_create(db_class, db_objects)
+          db_class.insert_all!(db_objects.map(&:attributes))
+        elsif defined? ActiveRecord::Import
           db_class.import(db_objects, validate: false)
         else
           db_objects.each do |db_object|
@@ -19,8 +24,15 @@ module Vorpal
       end
 
       def update(db_class, db_objects)
-        db_objects.each do |db_object|
-          db_object.save!(validate: false)
+        if ActiveRecord::VERSION::MAJOR >= 6
+          return if db_objects.empty?
+
+          update_timestamps_on_update(db_class, db_objects)
+          db_class.upsert_all(db_objects.map(&:attributes))
+        else
+          db_objects.each do |db_object|
+            db_object.save!(validate: false)
+          end
         end
       end
 
@@ -28,12 +40,12 @@ module Vorpal
         db_class.where(id: ids).delete_all
       end
 
-      # Loads instances of the given class by primary key.
+      # Loads instances of the given class by a unique key.
       #
       # @param db_class [Class] A subclass of ActiveRecord::Base
       # @return [[Object]] An array of entities.
-      def load_by_id(db_class, ids)
-        db_class.where(id: ids).to_a
+      def load_by_unique_key(db_class, ids, column_name)
+        db_class.where(column_name => ids).to_a
       end
 
       # Loads instances of the given class whose foreign key has the given value.
@@ -100,6 +112,30 @@ module Vorpal
 
       private
 
+      # Adapted from https://github.com/rails/rails/blob/614580270d7789e5275defc3da020ce27b3b2302/activerecord/lib/active_record/timestamp.rb#L99
+      def update_timestamps_on_create(db_class, db_objects)
+        return unless db_class.record_timestamps
+
+        current_time = db_class.current_time_from_proper_timezone
+        db_objects.each do |db_object|
+          db_class.all_timestamp_attributes_in_model.each do |column|
+            db_object.write_attribute(column, current_time) unless db_object.read_attribute(column)
+          end
+        end
+      end
+
+      #Adapted from https://github.com/rails/rails/blob/614580270d7789e5275defc3da020ce27b3b2302/activerecord/lib/active_record/timestamp.rb#L111
+      def update_timestamps_on_update(db_class, db_objects)
+        return unless db_class.record_timestamps
+
+        current_time = db_class.current_time_from_proper_timezone
+        db_objects.each do |db_object|
+          db_class.timestamp_attributes_for_update_in_model.each do |column|
+            db_object.write_attribute(column, current_time)
+          end
+        end
+      end
+
       def sequence_name(db_class)
         @sequence_names[db_class] ||= execute(
           "SELECT substring(column_default from '''(.*)''') FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name = $1 AND column_name = 'id' LIMIT 1",

data/lib/vorpal/dsl/config_builder.rb

@@ -1,4 +1,7 @@
-require 'vorpal/configs'
+require 'vorpal/config/class_config'
+require 'vorpal/config/has_many_config'
+require 'vorpal/config/has_one_config'
+require 'vorpal/config/belongs_to_config'
 require 'vorpal/dsl/defaults_generator'
 
 module Vorpal
@@ -16,74 +19,32 @@ module Vorpal
       @defaults_generator = DefaultsGenerator.new(clazz, db_driver)
     end
 
-    # Maps the given attributes to and from the domain object and the DB. Not needed
-    # if a serializer and deserializer were provided.
+    # @private
     def attributes(*attributes)
       @attributes.concat(attributes)
     end
 
-    # Defines a one-to-many association to another type where the foreign key is stored on the child.
-    #
-    # In Object-Oriented programming, associations are *directed*. This means that they can only be
-    # traversed in one direction: from the type that defines the association (the one with the
-    # getter) to the type that is associated. They end that defines the association is called the
-    # 'Parent' and the end that is associated is called the 'Child'.
-    #
-    # @param name [String] Name of the association getter.
-    # @param options [Hash]
-    # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
-    # @option options [String] :fk (Parent class name converted to snakecase and appended with a '_id') The name of the DB column on the child that contains the foreign key reference to the parent.
-    # @option options [String] :fk_type The name of the DB column on the child that contains the parent class name. Only needed when there is an association from the child side that is polymorphic.
-    # @option options [Class] :child_class (name converted to a Class) The child class.
+    # @private
     def has_many(name, options={})
-      @has_manys << {name: name}.merge(options)
+      @has_manys << build_has_many({name: name}.merge(options))
     end
 
-    # Defines a one-to-one association to another type where the foreign key
-    # is stored on the child.
-    #
-    # In Object-Oriented programming, associations are *directed*. This means that they can only be
-    # traversed in one direction: from the type that defines the association (the one with the
-    # getter) to the type that is associated. They end that defines the association is called the
-    # 'Parent' and the end that is associated is called the 'Child'.
-    #
-    # @param name [String] Name of the association getter.
-    # @param options [Hash]
-    # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
-    # @option options [String] :fk (Parent class name converted to snakecase and appended with a '_id') The name of the DB column on the child that contains the foreign key reference to the parent.
-    # @option options [String] :fk_type The name of the DB column on the child that contains the parent class name. Only needed when there is an association from the child side that is polymorphic.
-    # @option options [Class] :child_class (name converted to a Class) The child class.
+    # @private
     def has_one(name, options={})
-      @has_ones << {name: name}.merge(options)
+      @has_ones << build_has_one({name: name}.merge(options))
     end
 
-    # Defines a one-to-one association with another type where the foreign key
-    # is stored on the parent.
-    #
-    # This association can be polymorphic. I.E. children can be of different types.
-    #
-    # In Object-Oriented programming, associations are *directed*. This means that they can only be
-    # traversed in one direction: from the type that defines the association (the one with the
-    # getter) to the type that is associated. They end that defines the association is called the
-    # 'Parent' and the end that is associated is called the 'Child'.
-    #
-    # @param name [String] Name of the association getter.
-    # @param options [Hash]
-    # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
-    # @option options [String] :fk (Child class name converted to snakecase and appended with a '_id') The name of the DB column on the parent that contains the foreign key reference to the child.
-    # @option options [String] :fk_type The name of the DB column on the parent that contains the child class name. Only needed when the association is polymorphic.
-    # @option options [Class] :child_class (name converted to a Class) The child class.
-    # @option options [[Class]] :child_classes The list of possible classes that can be children. This is for polymorphic associations. Takes precedence over `:child_class`.
+    # @private
     def belongs_to(name, options={})
-      @belongs_tos << {name: name}.merge(options)
+      @belongs_tos << build_belongs_to({name: name}.merge(options))
     end
 
     # @private
     def build
       class_config = build_class_config
-      class_config.has_manys = build_has_manys
-      class_config.has_ones = build_has_ones
-      class_config.belongs_tos = build_belongs_tos
+      class_config.has_manys = @has_manys
+      class_config.has_ones = @has_ones
+      class_config.belongs_tos = @belongs_tos
 
       class_config
     end
@@ -96,46 +57,38 @@ module Vorpal
     private
 
     def build_class_config
-      Vorpal::ClassConfig.new(
+      Vorpal::Config::ClassConfig.new(
         domain_class: @domain_class,
         db_class: @class_options[:to] || @defaults_generator.build_db_class(@class_options[:table_name]),
         serializer: @class_options[:serializer] || @defaults_generator.serializer(attributes_with_id),
         deserializer: @class_options[:deserializer] || @defaults_generator.deserializer(attributes_with_id),
+        primary_key_type: @class_options[:primary_key_type] || @class_options[:id] || :serial,
       )
     end
 
-    def build_has_manys
-      @has_manys.map { |options| build_has_many(options) }
-    end
-
     def build_has_many(options)
-      options[:child_class] ||= @defaults_generator.child_class(options[:name])
+      options[:associated_class] ||= options[:child_class] || @defaults_generator.associated_class(options[:name])
       options[:fk] ||= @defaults_generator.foreign_key(@domain_class.name)
+      options[:unique_key_name] ||= (options[:primary_key] || "id")
       options[:owned] = options.fetch(:owned, true)
-      Vorpal::HasManyConfig.new(options)
-    end
-
-    def build_has_ones
-      @has_ones.map { |options| build_has_one(options) }
+      Vorpal::Config::HasManyConfig.new(options)
     end
 
     def build_has_one(options)
-      options[:child_class] ||= @defaults_generator.child_class(options[:name])
+      options[:associated_class] ||= options[:child_class] || @defaults_generator.associated_class(options[:name])
       options[:fk] ||= @defaults_generator.foreign_key(@domain_class.name)
+      options[:unique_key_name] ||= (options[:primary_key] || "id")
       options[:owned] = options.fetch(:owned, true)
-      Vorpal::HasOneConfig.new(options)
-    end
-
-    def build_belongs_tos
-      @belongs_tos.map { |options| build_belongs_to(options) }
+      Vorpal::Config::HasOneConfig.new(options)
     end
 
     def build_belongs_to(options)
-      child_class = options[:child_classes] || options[:child_class] || @defaults_generator.child_class(options[:name])
-      options[:child_classes] = Array(child_class)
+      associated_classes = options[:associated_classes] || options[:child_classes] || options[:associated_class] || options[:child_class] || @defaults_generator.associated_class(options[:name])
+      options[:associated_classes] = Array(associated_classes)
       options[:fk] ||= @defaults_generator.foreign_key(options[:name])
+      options[:unique_key_name] ||= (options[:primary_key] || "id")
       options[:owned] = options.fetch(:owned, true)
-      Vorpal::BelongsToConfig.new(options)
+      Vorpal::Config::BelongsToConfig.new(options)
     end
   end
   end