inventory_refresh 0.2.3 → 0.3.0

data/lib/inventory_refresh/inventory_collection/scanner.rb

@@ -41,7 +41,6 @@ module InventoryRefresh
       # Boolean helpers the scanner uses from the :inventory_collection
       delegate :inventory_object_lazy?,
                :inventory_object?,
-               :targeted?,
                :to => :inventory_collection
 
       # Methods the scanner uses from the :inventory_collection
@@ -52,18 +51,13 @@ module InventoryRefresh
                :to => :inventory_collection
 
       # The data scanner modifies inside of the :inventory_collection
-      delegate :all_manager_uuids_scope,
-               :association,
+      delegate :association,
                :arel,
                :attribute_references,
                :custom_save_block,
                :data_collection_finalized=,
                :dependency_attributes,
-               :targeted?,
-               :targeted_scope,
                :parent,
-               :parent_inventory_collections,
-               :parent_inventory_collections=,
                :references,
                :transitive_dependency_attributes,
                :to => :inventory_collection
@@ -78,11 +72,6 @@ module InventoryRefresh
         # Scan InventoryCollection InventoryObjects and store the results inside of the InventoryCollection
         data.each do |inventory_object|
           scan_inventory_object!(inventory_object)
-
-          if targeted? && parent_inventory_collections.blank?
-            # We want to track what manager_uuids we should query from a db, for the targeted refresh
-            targeted_scope << inventory_object.reference
-          end
         end
 
         # Scan InventoryCollection skeletal data
@@ -90,80 +79,12 @@ module InventoryRefresh
           scan_inventory_object!(inventory_object)
         end
 
-        build_parent_inventory_collections!
-        scan_all_manager_uuids_scope!
-
         # Mark InventoryCollection as finalized aka. scanned
         self.data_collection_finalized = true
       end
 
       private
 
-      def scan_all_manager_uuids_scope!
-        return if all_manager_uuids_scope.nil?
-
-        all_manager_uuids_scope.each do |scope|
-          scope.each_value do |value|
-            scan_all_manager_uuids_scope_attribute!(value)
-          end
-        end
-      end
-
-      def build_parent_inventory_collections!
-        if parent_inventory_collections.nil?
-          build_parent_inventory_collection!
-        else
-          # We can't figure out what immediate parent is, we'll add parent_inventory_collections as dependencies
-          parent_inventory_collections.each { |ic_name| add_parent_inventory_collection_dependency!(ic_name) }
-        end
-
-        return if parent_inventory_collections.blank?
-
-        # Transform InventoryCollection object names to actual objects
-        self.parent_inventory_collections = parent_inventory_collections.map { |x| load_inventory_collection_by_name(x) }
-      end
-
-      def build_parent_inventory_collection!
-        return unless supports_building_inventory_collection?
-
-        if association.present? && parent.present? && associations_hash[association].present?
-          # Add immediate parent IC as dependency
-          add_parent_inventory_collection_dependency!(associations_hash[association])
-          # Add root IC in parent_inventory_collections
-          self.parent_inventory_collections = [find_parent_inventory_collection(associations_hash, inventory_collection.association)]
-        end
-      end
-
-      def supports_building_inventory_collection?
-        # Don't try to introspect ICs with custom query or saving code
-        return if arel.present? || custom_save_block.present?
-        # We support :parent_inventory_collections only for targeted mode, where all ICs are present
-        return unless targeted?
-
-        true
-      end
-
-      def add_parent_inventory_collection_dependency!(ic_name)
-        ic = load_inventory_collection_by_name(ic_name)
-        (dependency_attributes[:__parent_inventory_collections] ||= Set.new) << ic if ic
-      end
-
-      def find_parent_inventory_collection(hash, name)
-        if hash[name]
-          find_parent_inventory_collection(hash, hash[name])
-        else
-          name
-        end
-      end
-
-      def load_inventory_collection_by_name(name)
-        ic = indexed_inventory_collections[name]
-        if ic.nil?
-          raise "Can't find InventoryCollection :#{name} referenced from #{inventory_collection}" if targeted?
-        end
-        ic
-      end
-
       def scan_inventory_object!(inventory_object)
         inventory_object.data.each do |key, value|
           if value.kind_of?(Array)
@@ -182,13 +103,6 @@ module InventoryRefresh
         value_inventory_collection.add_reference(value.reference, :key => value.key)
       end
 
-      def scan_all_manager_uuids_scope_attribute!(value)
-        return unless loadable?(value)
-
-        add_reference(value.inventory_collection, value)
-        (dependency_attributes[:__all_manager_uuids_scope] ||= Set.new) << value.inventory_collection
-      end
-
       def scan_inventory_object_attribute!(key, value)
         return unless loadable?(value)
         value_inventory_collection = value.inventory_collection

data/lib/inventory_refresh/inventory_collection/serialization.rb

@@ -3,10 +3,7 @@ require "active_support/core_ext/module/delegation"
 module InventoryRefresh
   class InventoryCollection
     class Serialization
-      delegate :all_manager_uuids,
-               :all_manager_uuids=,
-               :build,
-               :targeted_scope,
+      delegate :build,
                :data,
                :inventory_object_lazy?,
                :inventory_object?,
@@ -28,8 +25,6 @@ module InventoryRefresh
       # @param available_inventory_collections [Array<InventoryRefresh::InventoryCollection>] List of available
       #        InventoryCollection objects
       def from_hash(inventory_objects_data, available_inventory_collections)
-        targeted_scope.merge!(inventory_objects_data["manager_uuids"].map(&:symbolize_keys!)) if inventory_objects_data["manager_uuids"]
-
         (inventory_objects_data['data'] || []).each do |inventory_object_data|
           build(hash_to_data(inventory_object_data, available_inventory_collections).symbolize_keys!)
         end
@@ -37,8 +32,12 @@ module InventoryRefresh
         (inventory_objects_data['partial_data'] || []).each do |inventory_object_data|
           skeletal_primary_index.build(hash_to_data(inventory_object_data, available_inventory_collections).symbolize_keys!)
         end
+      end
 
-        self.all_manager_uuids = inventory_objects_data['all_manager_uuids']
+      def sweep_scope_from_hash(sweep_scope, available_inventory_collections)
+        sweep_scope.map do |s|
+          hash_to_data(s, available_inventory_collections).symbolize_keys!
+        end
       end
 
       # Serializes InventoryCollection's data storage into Array of Hashes
@@ -47,14 +46,15 @@ module InventoryRefresh
       def to_hash
         {
           :name              => name,
-          # TODO(lsmola) we do not support nested references here, should we?
-          :manager_uuids     => targeted_scope.primary_references.values.map(&:full_reference),
-          :all_manager_uuids => all_manager_uuids,
           :data              => data.map { |x| data_to_hash(x.data) },
           :partial_data      => skeletal_primary_index.index_data.map { |x| data_to_hash(x.data) },
         }
       end
 
+      def sweep_scope_to_hash(sweep_scope)
+        sweep_scope.map { |x| data_to_hash(x) }
+      end
+
       private
 
       # Converts InventoryRefresh::InventoryObject or InventoryRefresh::InventoryObjectLazy into Hash
@@ -107,10 +107,6 @@ module InventoryRefresh
         hash.transform_values do |value|
           if value.kind_of?(Hash) && value['inventory_collection_name']
             hash_to_lazy_relation(value, available_inventory_collections, depth)
-          elsif value.kind_of?(Array) && value.first.kind_of?(Hash) && value.first['inventory_collection_name']
-            # TODO(lsmola) do we need to compact it sooner? What if first element is nil? On the other hand, we want to
-            # deprecate this Vm HABTM assignment because it's not effective
-            value.compact.map { |x| hash_to_lazy_relation(x, available_inventory_collections, depth) }
           else
             value
           end
@@ -128,8 +124,6 @@ module InventoryRefresh
         data.transform_values do |value|
           if inventory_object_lazy?(value) || inventory_object?(value)
             lazy_relation_to_hash(value, depth)
-          elsif value.kind_of?(Array) && (inventory_object_lazy?(value.compact.first) || inventory_object?(value.compact.first))
-            value.compact.map { |x| lazy_relation_to_hash(x, depth) }
           else
             value
           end

data/lib/inventory_refresh/inventory_collection.rb

@@ -71,32 +71,14 @@ module InventoryRefresh
     #   InventoryCollection, since it is already persisted into the DB.
     attr_accessor :saved
 
-    # If present, InventoryCollection switches into delete_complement mode, where it will
-    # delete every record from the DB, that is not present in this list. This is used for the batch processing,
-    # where we don't know which InventoryObject should be deleted, but we know all manager_uuids of all
-    # InventoryObject objects that exists in the provider.
-    #
-    # @return [Array, nil] nil or a list of all :manager_uuids that are present in the Provider's InventoryCollection.
-    attr_accessor :all_manager_uuids
-
-    # @return [Array, nil] Scope for applying :all_manager_uuids
-    attr_accessor :all_manager_uuids_scope
-
-    # @return [String] Timestamp in UTC before fetching :all_manager_uuids
-    attr_accessor :all_manager_uuids_timestamp
-
     # @return [Set] A set of InventoryCollection objects that depends on this InventoryCollection object.
     attr_accessor :dependees
 
-    # @return [Array<Symbol>] @see #parent_inventory_collections documentation of InventoryCollection.new's initialize_ic_relations()
-    #   parameters
-    attr_accessor :parent_inventory_collections
-
     attr_reader :model_class, :strategy, :attributes_blacklist, :attributes_whitelist, :custom_save_block, :parent,
-                :internal_attributes, :delete_method, :dependency_attributes, :manager_ref, :create_only,
+                :internal_attributes, :dependency_attributes, :manager_ref, :secondary_refs, :create_only,
                 :association, :complete, :update_only, :transitive_dependency_attributes, :check_changed, :arel,
-                :inventory_object_attributes, :name, :saver_strategy, :targeted_scope, :default_values,
-                :targeted_arel, :targeted, :manager_ref_allowed_nil, :use_ar_object,
+                :inventory_object_attributes, :name, :saver_strategy, :default_values,
+                :manager_ref_allowed_nil, :use_ar_object,
                 :created_records, :updated_records, :deleted_records, :retention_strategy,
                 :custom_reconnect_block, :batch_extra_attributes, :references_storage, :unconnected_edges,
                 :assert_graph_integrity
@@ -130,7 +112,6 @@ module InventoryRefresh
              :lazy_find_by,
              :named_ref,
              :primary_index,
-             :reindex_secondary_indexes!,
              :skeletal_primary_index,
              :to => :index_proxy
 
@@ -153,28 +134,18 @@ module InventoryRefresh
                  properties[:check_changed],
                  properties[:update_only],
                  properties[:use_ar_object],
-                 properties[:targeted],
                  properties[:assert_graph_integrity])
 
       init_strategies(properties[:strategy],
-                      properties[:saver_strategy],
-                      properties[:retention_strategy],
-                      properties[:delete_method])
+                      properties[:retention_strategy])
 
       init_references(properties[:manager_ref],
                       properties[:manager_ref_allowed_nil],
-                      properties[:secondary_refs],
-                      properties[:manager_uuids])
+                      properties[:secondary_refs])
 
-      init_all_manager_uuids(properties[:all_manager_uuids],
-                             properties[:all_manager_uuids_scope],
-                             properties[:all_manager_uuids_timestamp])
+      init_ic_relations(properties[:dependency_attributes])
 
-      init_ic_relations(properties[:dependency_attributes],
-                        properties[:parent_inventory_collections])
-
-      init_arels(properties[:arel],
-                 properties[:targeted_arel])
+      init_arels(properties[:arel])
 
       init_custom_procs(properties[:custom_save_block],
                         properties[:custom_reconnect_block])
@@ -311,6 +282,11 @@ module InventoryRefresh
       @base_columns ||= (unique_index_columns + internal_columns + not_null_columns).uniq
     end
 
+    # @return [Array<Symbol>] Array of all column names on the InventoryCollection
+    def all_column_names
+      @all_column_names ||= model_class.columns.map { |x| x.name.to_sym }
+    end
+
     # @param value [Object] Object we want to test
     # @return [Boolean] true is value is kind of InventoryRefresh::InventoryObject
     def inventory_object?(value)
@@ -335,7 +311,7 @@ module InventoryRefresh
 
     # Convert manager_ref list of attributes to list of DB columns
     #
-    # @return [Array<String>] true is processing of this InventoryCollection will be in targeted mode
+    # @return [Array<String>] Converted manager_ref list of attributes to list of DB columns
     def manager_ref_to_cols
       # TODO(lsmola) this should contain the polymorphic _type, otherwise the IC with polymorphic unique key will get
       # conflicts
@@ -434,7 +410,6 @@ module InventoryRefresh
                               :parent                => parent,
                               :arel                  => arel,
                               :strategy              => strategy,
-                              :saver_strategy        => saver_strategy,
                               :custom_save_block     => custom_save_block,
                               # We want cloned IC to be update only, since this is used for cycle resolution
                               :update_only           => true,
@@ -472,78 +447,31 @@ module InventoryRefresh
 
     # @return [Integer] default batch size for talking to the DB
     def batch_size
-      # TODO(lsmola) mode to the settings
       1000
     end
 
     # @return [Integer] default batch size for talking to the DB if not using ApplicationRecord objects
     def batch_size_pure_sql
-      # TODO(lsmola) mode to the settings
       10_000
     end
 
-    # Returns a list of stringified uuids of all scoped InventoryObjects, which is used for scoping in targeted mode
-    #
-    # @return [Array<String>] list of stringified uuids of all scoped InventoryObjects
-    def manager_uuids
-      # TODO(lsmola) LEGACY: this is still being used by :targetel_arel definitions and it expects array of strings
-      raise "This works only for :manager_ref size 1" if manager_ref.size > 1
-      key = manager_ref.first
-      transform_references_to_hashes(targeted_scope.primary_references).map { |x| x[key] }
-    end
-
     # Builds a multiselection conditions like (table1.a = a1 AND table2.b = b1) OR (table1.a = a2 AND table2.b = b2)
     #
     # @param hashes [Array<Hash>] data we want to use for the query
     # @param keys [Array<Symbol>] keys of attributes involved
     # @return [String] A condition usable in .where of an ActiveRecord relation
-    def build_multi_selection_condition(hashes, keys = manager_ref)
+    def build_multi_selection_condition(hashes, keys = unique_index_keys)
       arel_table = model_class.arel_table
       # We do pure SQL OR, since Arel is nesting every .or into another parentheses, otherwise this would be just
       # inject(:or) instead of to_sql with .join(" OR ")
       hashes.map { |hash| "(#{keys.map { |key| arel_table[key].eq(hash[key]) }.inject(:and).to_sql})" }.join(" OR ")
     end
 
-    # @return [ActiveRecord::Relation] A relation that can fetch all data of this InventoryCollection from the DB
-    def db_collection_for_comparison
-      if targeted?
-        if targeted_arel.respond_to?(:call)
-          targeted_arel.call(self)
-        elsif parent_inventory_collections.present?
-          targeted_arel_default
-        else
-          targeted_iterator_for(targeted_scope.primary_references)
-        end
-      else
-        full_collection_for_comparison
-      end
-    end
-
-    # Builds targeted query limiting the results by the :references defined in parent_inventory_collections
-    #
-    # @return [InventoryRefresh::ApplicationRecordIterator] an iterator for default targeted arel
-    def targeted_arel_default
-      if parent_inventory_collections.collect { |x| x.model_class.base_class }.uniq.count > 1
-        raise "Multiple :parent_inventory_collections with different base class are not supported by default. Write "\
-              ":targeted_arel manually, or separate [#{self}] into 2 InventoryCollection objects."
-      end
-      parent_collection = parent_inventory_collections.first
-      references        = parent_inventory_collections.map { |x| x.targeted_scope.primary_references }.reduce({}, :merge!)
-
-      parent_collection.targeted_iterator_for(references, full_collection_for_comparison)
-    end
-
-    # Gets targeted references and transforms them into list of hashes
+    # Returns iterator for the passed references and a query
     #
-    # @param references [Array, InventoryRefresh::InventoryCollection::TargetedScope] passed references
-    # @return [Array<Hash>] References transformed into the array of hashes
-    def transform_references_to_hashes(references)
-      if references.kind_of?(Array)
-        # Sliced InventoryRefresh::InventoryCollection::TargetedScope
-        references.map { |x| x.second.full_reference }
-      else
-        references.values.map(&:full_reference)
-      end
+    # @return [InventoryRefresh::ApplicationRecordIterator] Iterator for the references and query
+    def db_collection_for_comparison
+      InventoryRefresh::ApplicationRecordIterator.new(:inventory_collection => self)
     end
 
     # Builds a multiselection conditions like (table1.a = a1 AND table2.b = b1) OR (table1.a = a2 AND table2.b = b2)
@@ -552,20 +480,20 @@ module InventoryRefresh
     # @param references [Hash{String => InventoryRefresh::InventoryCollection::Reference}] passed references
     # @return [String] A condition usable in .where of an ActiveRecord relation
     def targeted_selection_for(references)
-      build_multi_selection_condition(transform_references_to_hashes(references))
+      build_multi_selection_condition(references.map(&:second))
     end
 
-    # Returns iterator for the passed references and a query
-    #
-    # @param references [Hash{String => InventoryRefresh::InventoryCollection::Reference}] Passed references
-    # @param query [ActiveRecord::Relation] relation that can fetch all data of this InventoryCollection from the DB
-    # @return [InventoryRefresh::ApplicationRecordIterator] Iterator for the references and query
-    def targeted_iterator_for(references, query = nil)
-      InventoryRefresh::ApplicationRecordIterator.new(
-        :inventory_collection => self,
-        :manager_uuids_set    => references,
-        :query                => query
-      )
+    def select_keys
+      @select_keys ||= [@model_class.primary_key] + manager_ref_to_cols.map(&:to_s) + internal_columns.map(&:to_s)
+    end
+
+    # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter] ActiveRecord connection
+    def get_connection
+      ActiveRecord::Base.connection
+    end
+
+    def pure_sql_record_fetching?
+      !use_ar_object?
     end
 
     # Builds an ActiveRecord::Relation that can fetch all the references from the DB
@@ -573,14 +501,18 @@ module InventoryRefresh
     # @param references [Hash{String => InventoryRefresh::InventoryCollection::Reference}] passed references
     # @return [ActiveRecord::Relation] relation that can fetch all the references from the DB
     def db_collection_for_comparison_for(references)
-      full_collection_for_comparison.where(targeted_selection_for(references))
+      query = full_collection_for_comparison.where(targeted_selection_for(references))
+      if pure_sql_record_fetching?
+        return get_connection.query(query.select(*select_keys).to_sql)
+      end
+
+      query
     end
 
     # @return [ActiveRecord::Relation] relation that can fetch all the references from the DB
     def full_collection_for_comparison
       return arel unless arel.nil?
       rel = parent.send(association)
-      rel = rel.active if rel && supports_column?(:archived_at) && retention_strategy == :archive
       rel
     end
 
@@ -634,11 +566,5 @@ module InventoryRefresh
         :id => identity
       }
     end
-
-    # TODO: Not used!
-    # @return [Array<Symbol>] all association attributes and foreign keys of the model class
-    def association_attributes
-      model_class.reflect_on_all_associations.map { |x| [x.name, x.foreign_key] }.flatten.compact.map(&:to_sym)
-    end
   end
 end

data/lib/inventory_refresh/inventory_object.rb

@@ -42,64 +42,12 @@ module InventoryRefresh
     # Transforms InventoryObject object data into hash format with keys that are column names and resolves correct
     # values of the foreign keys (even the polymorphic ones)
     #
-    # @param inventory_collection_scope [InventoryRefresh::InventoryCollection] parent InventoryCollection object
-    # @return [Hash] Data in DB format
-    def attributes(inventory_collection_scope = nil)
-      # We should explicitly pass a scope, since the inventory_object can be mapped to more InventoryCollections with
-      # different blacklist and whitelist. The generic code always passes a scope.
-      inventory_collection_scope ||= inventory_collection
-
-      attributes_for_saving = {}
-      # First transform the values
-      data.each do |key, value|
-        if !allowed?(inventory_collection_scope, key)
-          next
-        elsif value.kind_of?(Array) && value.any? { |x| loadable?(x) }
-          # Lets fill also the original data, so other InventoryObject referring to this attribute gets the right
-          # result
-          data[key] = value.compact.map(&:load).compact
-          # We can use built in _ids methods to assign array of ids into has_many relations. So e.g. the :key_pairs=
-          # relation setter will become :key_pair_ids=
-          attributes_for_saving[(key.to_s.singularize + "_ids").to_sym] = data[key].map(&:id).compact.uniq
-        elsif loadable?(value) || inventory_collection_scope.association_to_foreign_key_mapping[key]
-          # Lets fill also the original data, so other InventoryObject referring to this attribute gets the right
-          # result
-          data[key] = value.load if value.respond_to?(:load)
-          if (foreign_key = inventory_collection_scope.association_to_foreign_key_mapping[key])
-            # We have an association to fill, lets fill also the :key, cause some other InventoryObject can refer to it
-            record_id                                 = data[key].try(:id)
-            attributes_for_saving[foreign_key.to_sym] = record_id
-
-            if (foreign_type = inventory_collection_scope.association_to_foreign_type_mapping[key])
-              # If we have a polymorphic association, we need to also fill a base class name, but we want to nullify it
-              # if record_id is missing
-              base_class = data[key].try(:base_class_name) || data[key].class.try(:base_class).try(:name)
-              attributes_for_saving[foreign_type.to_sym] = record_id ? base_class : nil
-            end
-          elsif data[key].kind_of?(::InventoryRefresh::InventoryObject)
-            # We have an association to fill but not an Activerecord association, so e.g. Ancestry, lets just load
-            # it here. This way of storing ancestry is ineffective in DB call count, but RAM friendly
-            attributes_for_saving[key.to_sym] = data[key].base_class_name.constantize.find_by(:id => data[key].id)
-          else
-            # We have a normal attribute to fill
-            attributes_for_saving[key.to_sym] = data[key]
-          end
-        else
-          attributes_for_saving[key.to_sym] = value
-        end
-      end
-
-      attributes_for_saving
-    end
-
-    # Transforms InventoryObject object data into hash format with keys that are column names and resolves correct
-    # values of the foreign keys (even the polymorphic ones)
-    #
+    # @param data [Array<Object>] Array of objects that we want to map to DB table columns
     # @param inventory_collection_scope [InventoryRefresh::InventoryCollection] parent InventoryCollection object
     # @param all_attribute_keys [Array<Symbol>] Attribute keys we will modify based on object's data
     # @param inventory_object [InventoryRefresh::InventoryObject] InventoryObject object owning these attributes
     # @return [Hash] Data in DB format
-    def attributes_with_keys(inventory_collection_scope = nil, all_attribute_keys = [], inventory_object = nil)
+    def self.attributes_with_keys(data, inventory_collection_scope = nil, all_attribute_keys = [], inventory_object = nil)
       # We should explicitly pass a scope, since the inventory_object can be mapped to more InventoryCollections with
       # different blacklist and whitelist. The generic code always passes a scope.
       inventory_collection_scope ||= inventory_collection
@@ -206,6 +154,36 @@ module InventoryRefresh
       end
     end
 
+    # Return true if the attribute is allowed to be saved into the DB
+    #
+    # @param inventory_collection_scope [InventoryRefresh::InventoryCollection] InventoryCollection object owning the
+    #        attribute
+    # @param key [Symbol] attribute name
+    # @return true if the attribute is allowed to be saved into the DB
+    def self.allowed?(inventory_collection_scope, key)
+      foreign_to_association = (inventory_collection_scope.foreign_key_to_association_mapping[key] ||
+        inventory_collection_scope.foreign_type_to_association_mapping[key])
+
+      return false if inventory_collection_scope.attributes_blacklist.present? &&
+        (inventory_collection_scope.attributes_blacklist.include?(key) ||
+          (foreign_to_association && inventory_collection_scope.attributes_blacklist.include?(foreign_to_association)))
+
+      return false if inventory_collection_scope.attributes_whitelist.present? &&
+        (!inventory_collection_scope.attributes_whitelist.include?(key) &&
+          (!foreign_to_association || (foreign_to_association && inventory_collection_scope.attributes_whitelist.include?(foreign_to_association))))
+
+      true
+    end
+
+    # Return true if the object is loadable, which we determine by a list of loadable classes.
+    #
+    # @param value [Object] object we test
+    # @return true if the object is loadable
+    def self.loadable?(value)
+      value.kind_of?(::InventoryRefresh::InventoryObjectLazy) || value.kind_of?(::InventoryRefresh::InventoryObject) ||
+        value.kind_of?(::InventoryRefresh::ApplicationRecordReference)
+    end
+
     private
 
     # Assigns value based on the version attributes. If versions are specified, it asigns attribute only if it's
@@ -283,18 +261,7 @@ module InventoryRefresh
     # @param key [Symbol] attribute name
     # @return true if the attribute is allowed to be saved into the DB
     def allowed?(inventory_collection_scope, key)
-      foreign_to_association = inventory_collection_scope.foreign_key_to_association_mapping[key] ||
-                               inventory_collection_scope.foreign_type_to_association_mapping[key]
-
-      return false if inventory_collection_scope.attributes_blacklist.present? &&
-                      (inventory_collection_scope.attributes_blacklist.include?(key) ||
-                        (foreign_to_association && inventory_collection_scope.attributes_blacklist.include?(foreign_to_association)))
-
-      return false if inventory_collection_scope.attributes_whitelist.present? &&
-                      (!inventory_collection_scope.attributes_whitelist.include?(key) &&
-                        (!foreign_to_association || (foreign_to_association && inventory_collection_scope.attributes_whitelist.include?(foreign_to_association))))
-
-      true
+      self.class.allowed?(inventory_collection_scope, key)
     end
 
     # Return true if the object is loadable, which we determine by a list of loadable classes.
@@ -302,8 +269,7 @@ module InventoryRefresh
     # @param value [Object] object we test
     # @return true if the object is loadable
     def loadable?(value)
-      value.kind_of?(::InventoryRefresh::InventoryObjectLazy) || value.kind_of?(::InventoryRefresh::InventoryObject) ||
-        value.kind_of?(::InventoryRefresh::ApplicationRecordReference)
+      self.class.loadable?(value)
     end
   end
 end

data/lib/inventory_refresh/inventory_object_lazy.rb

@@ -30,7 +30,6 @@ module InventoryRefresh
 
     # @return [String] stringified reference
     def to_s
-      # TODO(lsmola) do we need this method?
       stringified_reference
     end
 
@@ -71,10 +70,6 @@ module InventoryRefresh
 
     # @return [Boolean] true if the key is an association on inventory_collection_scope model class
     def association?(key)
-      # TODO(lsmola) remove this if there will be better dependency scan, probably with transitive dependencies filled
-      # in a second pass, then we can get rid of this hardcoded symbols. Right now we are not able to introspect these.
-      return true if [:parent, :genealogy_parent].include?(key)
-
       inventory_collection.dependency_attributes.key?(key) ||
         !inventory_collection.association_to_foreign_key_mapping[key].nil?
     end
@@ -100,7 +95,7 @@ module InventoryRefresh
 
     private
 
-    delegate :parallel_safe?, :saved?, :saver_strategy, :skeletal_primary_index, :targeted?, :to => :inventory_collection
+    delegate :saved?, :saver_strategy, :skeletal_primary_index, :to => :inventory_collection
     delegate :nested_secondary_index?, :primary?, :full_reference, :keys, :primary?, :to => :reference
 
     attr_writer :reference
@@ -112,20 +107,18 @@ module InventoryRefresh
     #
     # @return [InventoryRefresh::InventoryObject, NilClass] Returns pre-created InventoryObject or nil
     def skeletal_precreate!
-      # We can do skeletal pre-create only for strategies using unique indexes. Since this can build records out of
-      # the given :arel scope, we will always attempt to create the recod, so we need unique index to avoid duplication
-      # of records.
-      return unless parallel_safe?
       # Pre-create only for strategies that will be persisting data, i.e. are not saved already
       return if saved?
       # We can only do skeletal pre-create for primary index reference, since that is needed to create DB unique index
-      return unless primary?
-      # Full reference must be present
-      return if full_reference.blank?
-
-      # To avoid pre-creating invalid records all fields of a primary key must have value
-      # TODO(lsmola) for composite keys, it's still valid to have one of the keys nil, figure out how to allow this
-      return if keys.any? { |x| full_reference[x].blank? }
+      # and full reference must be present
+      return if !primary? || full_reference.blank?
+
+      # To avoid pre-creating invalid records all fields of a primary key must have non null value
+      # TODO(lsmola) for composite keys, it's still valid to have one of the keys nil, figure out how to allow this. We
+      # will need to scan the DB for NOT NULL constraint and allow it based on that. So we would move this check to
+      # saving code, but this will require bigger change, since having the column nil means we will have to batch it
+      # smartly, since having nil means we will need to use different unique index for the upsert/update query.
+      return if keys.any? { |x| full_reference[x].nil? }
 
       skeletal_primary_index.build(full_reference)
     end