bulkrax 2.2.4 → 3.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ca4838e8fe86d901fd9196ab8c1a84f7072fae590a1fc411f8ee057756f9db9
-  data.tar.gz: 8b6dde2983bac873a5dbbd0f70aab512199344f00a2a7cbdcbea5f5b2a9fe4c5
+  metadata.gz: 0c05782edcfff4b5c460c3cc3bd8b3fbec355299a87c977b0400b2b555105de8
+  data.tar.gz: dd0316f5502afcea91ac0fa84f0ea6bcb1600aff9b867d5460e934aeafdaa9c2
 SHA512:
-  metadata.gz: 14ee5cdf3bfee220faebd377b6ce25979397c4b72ac9de3f10d92d13f57d60fffecb089e26f7bdc1c5ccb147430fb637635053e0a601a1f0f96ad2082d1d10b9
-  data.tar.gz: 0236d3b24309e7a0338d1fb38d40e0ab852ff452514311c5e7711fc8efcc39a19a48a044622b2168d43d1fd1517cd6a61a87273af350ab0dd91c6576230911d6
+  metadata.gz: fc72772040076f6e527adc335cb4dd6802c199f3b0e94ea81fab7d341d9354973fe76c08b9873e90d7244dd527617c60f0486e141736a589df2afd8e051bcd37
+  data.tar.gz: 3c39be004fd6196d8692643a567a73398a4cb4105a1174535f73cbf7b515b8ca0d6a2bbc8cdb05c012dca814f5bc5b57ab5bfc40a6191ec73fcd40c96eb3e630

data/app/factories/bulkrax/object_factory.rb

@@ -7,20 +7,15 @@ module Bulkrax
     include DynamicRecordLookup
 
     define_model_callbacks :save, :create
-    attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier, :collection_field_mapping, :related_parents_parsed_mapping
+    attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier, :related_parents_parsed_mapping
 
     # rubocop:disable Metrics/ParameterLists
-    def initialize(attributes:, source_identifier_value:, work_identifier:, collection_field_mapping:, related_parents_parsed_mapping: nil, replace_files: false, user: nil, klass: nil, update_files: false)
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
+    def initialize(attributes:, source_identifier_value:, work_identifier:, related_parents_parsed_mapping: nil, replace_files: false, user: nil, klass: nil, update_files: false)
       @attributes = ActiveSupport::HashWithIndifferentAccess.new(attributes)
       @replace_files = replace_files
       @update_files = update_files
       @user = user || User.batch_user
       @work_identifier = work_identifier
-      @collection_field_mapping = collection_field_mapping
       @related_parents_parsed_mapping = related_parents_parsed_mapping
       @source_identifier_value = source_identifier_value
       @klass = klass || Bulkrax.default_work_type.constantize
@@ -55,7 +50,7 @@ module Bulkrax
     def update
       raise "Object doesn't exist" unless object
       destroy_existing_files if @replace_files && ![Collection, FileSet].include?(klass)
-      attrs = attribute_update
+      attrs = transform_attributes(update: true)
       run_callbacks :save do
         if klass == Collection
           update_collection(attrs)
@@ -97,7 +92,7 @@ module Bulkrax
     # https://github.com/projecthydra/active_fedora/issues/874
     # 2+ years later, still open!
     def create
-      attrs = create_attributes
+      attrs = transform_attributes
       @object = klass.new
       object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX if object.respond_to?(:reindex_extent)
       run_callbacks :save do
@@ -142,25 +137,15 @@ module Bulkrax
     end
 
     def create_collection(attrs)
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       attrs = collection_type(attrs)
-      persist_collection_memberships(parent: object, child: find_collection(attributes[:child_collection_id])) if attributes[:child_collection_id].present?
-      persist_collection_memberships(parent: find_collection(attributes[collection_field_mapping]), child: object) if attributes[collection_field_mapping].present?
+      persist_collection_memberships(parent: find_collection(attributes[related_parents_parsed_mapping]), child: object) if attributes[related_parents_parsed_mapping].present?
       object.attributes = attrs
       object.apply_depositor_metadata(@user)
       object.save!
     end
 
     def update_collection(attrs)
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
-      persist_collection_memberships(parent: object, child: find_collection(attributes[:child_collection_id])) if attributes[:child_collection_id].present?
-      persist_collection_memberships(parent: find_collection(attributes[collection_field_mapping]), child: object) if attributes[collection_field_mapping].present?
+      persist_collection_memberships(parent: find_collection(attributes[related_parents_parsed_mapping]), child: object) if attributes[related_parents_parsed_mapping].present?
       object.attributes = attrs
       object.save!
     end
@@ -197,6 +182,10 @@ module Bulkrax
     # Add child to parent's #member_collections
     # Add parent to child's #member_of_collections
     def persist_collection_memberships(parent:, child:)
+      parent.reject!(&:blank?) if parent.respond_to?(:reject!)
+      child.reject!(&:blank?) if child.respond_to?(:reject!)
+      return if parent.blank? || child.blank?
+
       ::Hyrax::Collections::NestedCollectionPersistenceService.persist_nested_collection_for(parent: parent, child: child)
     end
 
@@ -205,7 +194,7 @@ module Bulkrax
       when Hash
         Collection.find(id[:id])
       when String
-        Collection.find(id)
+        Collection.find(id) if id.present?
       when Array
         id.map { |i| find_collection(i) }
       else
@@ -219,34 +208,12 @@ module Bulkrax
       attrs
     end
 
-    # Strip out the :collection key, and add the member_of_collection_ids,
-    # which is used by Hyrax::Actors::AddAsMemberOfCollectionsActor
-    def create_attributes
-      return transform_attributes if klass == Collection
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
-      transform_attributes.except(:collections, :collection, collection_field_mapping)
-    end
-
-    # Strip out the :collection key, and add the member_of_collection_ids,
-    # which is used by Hyrax::Actors::AddAsMemberOfCollectionsActor
-    def attribute_update
-      return transform_attributes.except(:id) if klass == Collection
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
-      transform_attributes.except(:id, :collections, :collection, collection_field_mapping)
-    end
-
     # Override if we need to map the attributes from the parser in
     # a way that is compatible with how the factory needs them.
-    def transform_attributes
+    def transform_attributes(update: false)
       @transform_attributes = attributes.slice(*permitted_attributes)
       @transform_attributes.merge!(file_attributes(update_files)) if with_files
-      @transform_attributes
+      update ? @transform_attributes.except(:id) : @transform_attributes
     end
 
     # Regardless of what the Parser gives us, these are the properties we are prepared to accept.

data/app/jobs/bulkrax/create_relationships_job.rb

@@ -21,11 +21,9 @@ module Bulkrax
 
     queue_as :import
 
-    attr_accessor :base_entry, :child_record, :parent_record, :importer_run
+    attr_accessor :child_records, :parent_record, :parent_entry, :importer_run_id
 
-    # @param entry_identifier [String] source_identifier of the base Bulkrax::Entry the job was triggered from (see #build_for_importer)
-    # @param parent_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifier
-    # @param child_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifier
+    # @param parent_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifiers
     # @param importer_run [Bulkrax::ImporterRun] current importer run (needed to properly update counters)
     #
     # The entry_identifier is used to lookup the @base_entry for the job (a.k.a. the entry the job was called from).
@@ -33,123 +31,117 @@ module Bulkrax
     # Whether the @base_entry is the parent or the child in the relationship is determined by the presence of a
     # parent_identifier or child_identifier param. For example, if a parent_identifier is passed, we know @base_entry
     # is the child in the relationship, and vice versa if a child_identifier is passed.
-    def perform(entry_identifier:, parent_identifier: nil, child_identifier: nil, importer_run:)
-      @base_entry = Entry.find_by(identifier: entry_identifier)
-      @importer_run = importer_run
-      if parent_identifier.present?
-        @child_record = find_record(entry_identifier)
-        @parent_record = find_record(parent_identifier)
-      elsif child_identifier.present?
-        @parent_record = find_record(entry_identifier)
-        @child_record = find_record(child_identifier)
-      else
-        raise ::StandardError, %("#{entry_identifier}" needs either a child or a parent to create a relationship)
+    def perform(parent_identifier:, importer_run_id:)
+      pending_relationships = Bulkrax::PendingRelationship.find_each.select do |rel|
+        rel.bulkrax_importer_run_id == importer_run_id && rel.parent_id == parent_identifier
+      end.sort_by(&:order)
+
+      @importer_run_id = importer_run_id
+      @parent_record = find_record(parent_identifier)
+      @child_records = { works: [], collections: [] }
+      pending_relationships.each do |rel|
+        raise ::StandardError, %("#{rel}" needs either a child or a parent to create a relationship) if rel.child_id.nil? || rel.parent_id.nil?
+        child_record = find_record(rel.child_id)
+        child_record.is_a?(::Collection) ? @child_records[:collections] << child_record : @child_records[:works] << child_record
       end
 
-      if @child_record.blank? || @parent_record.blank?
+      if (child_records[:collections].blank? && child_records[:works].blank?) || parent_record.blank?
         reschedule(
-          entry_identifier: entry_identifier,
           parent_identifier: parent_identifier,
-          child_identifier: child_identifier,
-          importer_run: importer_run
+          importer_run_id: importer_run_id
         )
         return false # stop current job from continuing to run after rescheduling
       end
 
-      create_relationship
+      @parent_entry = Bulkrax::Entry.where(identifier: parent_identifier,
+                                           importerexporter_id: ImporterRun.find(importer_run_id).importer_id,
+                                           importerexporter_type: "Bulkrax::Importer").first
+      create_relationships
+      pending_relationships.each(&:destroy)
     rescue ::StandardError => e
-      base_entry.status_info(e)
-      importer_run.increment!(:failed_relationships) # rubocop:disable Rails/SkipsModelValidations
+      parent_entry.status_info(e)
+      Bulkrax::ImporterRun.find(importer_run_id).increment!(:failed_relationships) # rubocop:disable Rails/SkipsModelValidations
     end
 
     private
 
-    def create_relationship
-      if parent_record.is_a?(::Collection) && child_record.is_a?(::Collection)
-        collection_parent_collection_child
-      elsif parent_record.is_a?(::Collection) && curation_concern?(child_record)
-        collection_parent_work_child
-      elsif curation_concern?(parent_record) && child_record.is_a?(::Collection)
-        raise ::StandardError, 'a Collection may not be assigned as a child of a Work'
+    def create_relationships
+      if parent_record.is_a?(::Collection)
+        collection_parent_work_child unless child_records[:works].empty?
+        collection_parent_collection_child unless child_records[:collections].empty?
       else
-        work_parent_work_child
+        work_parent_work_child unless child_records[:works].empty?
+        raise ::StandardError, 'a Collection may not be assigned as a child of a Work' if child_records[:collections].present?
       end
     end
 
     def user
-      @user ||= importer_run.importer.user
+      @user ||= Bulkrax::ImporterRun.find(importer_run_id).importer.user
     end
 
     # Work-Collection membership is added to the child as member_of_collection_ids
     # This is adding the reverse relationship, from the child to the parent
     def collection_parent_work_child
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
-      attrs = { id: child_record.id, member_of_collections_attributes: { 0 => { id: parent_record.id } } }
-      ObjectFactory.new(
-        attributes: attrs,
-        source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
-        work_identifier: base_entry.parser.work_identifier,
-        collection_field_mapping: base_entry.parser.collection_field_mapping,
-        replace_files: false,
-        user: user,
-        klass: child_record.class
-      ).run
-      # TODO: add counters for :processed_parents and :failed_parents
-      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+      child_records[:works].each do |child_record|
+        attrs = { id: child_record.id, member_of_collections_attributes: { 0 => { id: parent_record.id } } }
+        ObjectFactory.new(
+          attributes: attrs,
+          source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
+          work_identifier: parent_entry.parser.work_identifier,
+          related_parents_parsed_mapping: parent_entry.parser.related_parents_parsed_mapping,
+          replace_files: false,
+          user: user,
+          klass: child_record.class
+        ).run
+        # TODO: add counters for :processed_parents and :failed_parents
+        Bulkrax::ImporterRun.find(importer_run_id).increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+      end
     end
 
     # Collection-Collection membership is added to the as member_ids
     def collection_parent_collection_child
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
+      child_record = child_records[:collections].first
       attrs = { id: parent_record.id, child_collection_id: child_record.id }
       ObjectFactory.new(
         attributes: attrs,
         source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
-        work_identifier: base_entry.parser.work_identifier,
-        collection_field_mapping: base_entry.parser.collection_field_mapping,
+        work_identifier: parent_entry.parser.work_identifier,
+        related_parents_parsed_mapping: parent_entry.parser.related_parents_parsed_mapping,
         replace_files: false,
         user: user,
         klass: parent_record.class
       ).run
       # TODO: add counters for :processed_parents and :failed_parents
-      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+      Bulkrax::ImporterRun.find(importer_run_id).increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
     end
 
     # Work-Work membership is added to the parent as member_ids
     def work_parent_work_child
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
+      records_hash = {}
+      child_records[:works].each_with_index do |child_record, i|
+        records_hash[i] = { id: child_record.id }
+      end
       attrs = {
         id: parent_record.id,
-        work_members_attributes: { 0 => { id: child_record.id } }
+        work_members_attributes: records_hash
       }
       ObjectFactory.new(
         attributes: attrs,
         source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
-        work_identifier: base_entry.parser.work_identifier,
-        collection_field_mapping: base_entry.parser.collection_field_mapping,
+        work_identifier: parent_entry.parser.work_identifier,
+        related_parents_parsed_mapping: parent_entry.parser.related_parents_parsed_mapping,
         replace_files: false,
         user: user,
         klass: parent_record.class
       ).run
       # TODO: add counters for :processed_parents and :failed_parents
-      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+      Bulkrax::ImporterRun.find(importer_run_id).increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
     end
 
-    def reschedule(entry_identifier:, parent_identifier:, child_identifier:, importer_run:)
+    def reschedule(parent_identifier:, importer_run_id:)
       CreateRelationshipsJob.set(wait: 10.minutes).perform_later(
-        entry_identifier: entry_identifier,
         parent_identifier: parent_identifier,
-        child_identifier: child_identifier,
-        importer_run: importer_run
+        importer_run_id: importer_run_id
       )
     end
   end

data/app/jobs/bulkrax/importer_job.rb

@@ -18,9 +18,7 @@ module Bulkrax
       importer.only_updates = only_updates_since_last_import || false
       return unless importer.valid_import?
 
-      importer.import_collections
-      importer.import_works
-      importer.import_file_sets
+      importer.import_objects
     end
 
     def unzip_imported_file(parser)

data/app/jobs/bulkrax/schedule_relationships_job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class ScheduleRelationshipsJob < ApplicationJob
+    def perform(importer_id:)
+      importer = Importer.find(importer_id)
+      pending_num = importer.entries.left_outer_joins(:latest_status)
+                            .where('bulkrax_statuses.status_message IS NULL ').count
+      return reschedule(importer_id) unless pending_num.zero?
+
+      importer.last_run.parents.each do |parent_id|
+        CreateRelationshipsJob.perform_later(parent_identifier: parent_id, importer_run_id: importer.last_run.id)
+      end
+    end
+
+    def reschedule(importer_id)
+      ScheduleRelationshipsJob.set(wait: 5.minutes).perform_later(importer_id: importer_id)
+      false
+    end
+  end
+end

data/app/models/bulkrax/csv_entry.rb

@@ -3,7 +3,10 @@
 require 'csv'
 
 module Bulkrax
-  class CsvEntry < Entry
+  # TODO: We need to rework this class some to address the Metrics/ClassLength rubocop offense.
+  # We do too much in these entry classes. We need to extract the common logic from the various
+  # entry models into a module that can be shared between them.
+  class CsvEntry < Entry # rubocop:disable Metrics/ClassLength
     serialize :raw_metadata, JSON
 
     def self.fields_from_data(data)
@@ -19,18 +22,15 @@ module Bulkrax
         encoding: 'utf-8')
     end
 
-    def self.data_for_entry(data, _source_id)
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
+    def self.data_for_entry(data, _source_id, parser)
       # If a multi-line CSV data is passed, grab the first row
       data = data.first if data.is_a?(CSV::Table)
       # model has to be separated so that it doesn't get mistranslated by to_h
       raw_data = data.to_h
       raw_data[:model] = data[:model] if data[:model].present?
       # If the collection field mapping is not 'collection', add 'collection' - the parser needs it
-      raw_data[:collection] = raw_data[collection_field.to_sym] if raw_data.keys.include?(collection_field.to_sym) && collection_field != 'collection'
+      # TODO: change to :parents
+      raw_data[:parents] = raw_data[parent_field(parser).to_sym] if raw_data.keys.include?(parent_field(parser).to_sym) && parent_field(parser) != 'parents'
       return raw_data
     end
 
@@ -44,7 +44,6 @@ module Bulkrax
       add_visibility
       add_metadata_for_model
       add_rights_statement
-      add_collections
       add_local
 
       self.parsed_metadata
@@ -67,15 +66,9 @@ module Bulkrax
     end
 
     def add_ingested_metadata
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       # we do not want to sort the values in the record before adding the metadata.
       # if we do, the factory_class will be set to the default_work_type for all values that come before "model" or "work type"
       record.each do |key, value|
-        next if self.parser.collection_field_mapping.to_s == key_without_numbers(key)
-
         index = key[/\d+/].to_i - 1 if key[/\d+/].to_i != 0
         add_metadata(key_without_numbers(key), value, index)
       end
@@ -101,28 +94,40 @@ module Bulkrax
       self.parsed_metadata['id'] = hyrax_record.id
       self.parsed_metadata[source_identifier] = hyrax_record.send(work_identifier)
       self.parsed_metadata['model'] = hyrax_record.has_model.first
+      build_relationship_metadata
       build_mapping_metadata
+      build_files unless hyrax_record.is_a?(Collection)
+      self.parsed_metadata
+    end
 
-      # TODO: fix the "send" parameter in the conditional below
-      # currently it returns: "NoMethodError - undefined method 'bulkrax_identifier' for #<Collection:0x00007fbe6a3b4248>"
-      if mapping['collection']&.[]('join')
-        self.parsed_metadata['collection'] = hyrax_record.member_of_collection_ids.join('; ')
-        #   self.parsed_metadata['collection'] = hyrax_record.member_of_collections.map { |c| c.send(work_identifier)&.first }.compact.uniq.join(';')
-      else
-        hyrax_record.member_of_collections.each_with_index do |collection, i|
-          self.parsed_metadata["collection_#{i + 1}"] = collection.id
-          #     self.parsed_metadata["collection_#{i + 1}"] = collection.send(work_identifier)&.first
+    def build_relationship_metadata
+      # Includes all relationship methods for all exportable record types (works, Collections, FileSets)
+      relationship_methods = {
+        related_parents_parsed_mapping => %i[member_of_collection_ids member_of_work_ids in_work_ids],
+        related_children_parsed_mapping => %i[member_collection_ids member_work_ids file_set_ids]
+      }
+
+      relationship_methods.each do |relationship_key, methods|
+        next if relationship_key.blank?
+
+        values = []
+        methods.each do |m|
+          values << hyrax_record.public_send(m) if hyrax_record.respond_to?(m)
         end
-      end
+        values = values.flatten.uniq
+        next if values.blank?
 
-      build_files unless hyrax_record.is_a?(Collection)
-      self.parsed_metadata
+        handle_join_on_export(relationship_key, values, mapping[related_parents_parsed_mapping]['join'].present?)
+      end
     end
 
     def build_mapping_metadata
       mapping.each do |key, value|
         next if Bulkrax.reserved_properties.include?(key) && !field_supported?(key)
         next if key == "model"
+        # relationships handled by #build_relationship_metadata
+        next if [related_parents_parsed_mapping, related_children_parsed_mapping].include?(key)
+        next if key == 'file' # handled by #build_files
         next if value['excluded']
 
         object_key = key if value.key?('object')
@@ -148,7 +153,7 @@ module Bulkrax
       data = hyrax_record.send(key.to_s)
       if data.is_a?(ActiveTriples::Relation)
         if value['join']
-          self.parsed_metadata[key_for_export(key)] = data.map { |d| prepare_export_data(d) }.join('; ').to_s
+          self.parsed_metadata[key_for_export(key)] = data.map { |d| prepare_export_data(d) }.join(' | ').to_s # TODO: make split char dynamic
         else
           data.each_with_index do |d, i|
             self.parsed_metadata["#{key_for_export(key)}_#{i + 1}"] = prepare_export_data(d)
@@ -197,12 +202,21 @@ module Bulkrax
     end
 
     def build_files
-      if mapping['file']&.[]('join')
-        self.parsed_metadata['file'] = hyrax_record.file_sets.map { |fs| filename(fs).to_s if filename(fs).present? }.compact.join('; ')
+      file_mapping = mapping['file']&.[]('from')&.first || 'file'
+      file_sets = hyrax_record.file_set? ? Array.wrap(hyrax_record) : hyrax_record.file_sets
+
+      filenames = file_sets.map { |fs| filename(fs).to_s if filename(fs).present? }.compact
+      handle_join_on_export(file_mapping, filenames, mapping['file']&.[]('join')&.present?)
+    end
+
+    def handle_join_on_export(key, values, join)
+      if join
+        parsed_metadata[key] = values.join(' | ') # TODO: make split char dynamic
       else
-        hyrax_record.file_sets.each_with_index do |fs, i|
-          self.parsed_metadata["file_#{i + 1}"] = filename(fs).to_s if filename(fs).present?
+        values.each_with_index do |value, i|
+          parsed_metadata["#{key}_#{i + 1}"] = value
         end
+        parsed_metadata.delete(key)
       end
     end
 
@@ -225,14 +239,19 @@ module Bulkrax
     end
 
     def possible_collection_ids
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
-      @possible_collection_ids ||= record.inject([]) do |memo, (key, value)|
-        memo += value.split(/\s*[:;|]\s*/) if self.class.collection_field.to_s == key_without_numbers(key) && value.present?
-        memo
-      end || []
+      return @possible_collection_ids if @possible_collection_ids.present?
+
+      collection_field_mapping = self.class.parent_field(parser)
+      return [] unless collection_field_mapping.present? && record[collection_field_mapping].present?
+
+      identifiers = []
+      split_titles = record[collection_field_mapping].split(/\s*[;|]\s*/)
+      split_titles.each do |c_title|
+        matching_collection_entries = importerexporter.entries.select { |e| e.raw_metadata['title'] == c_title }
+        raise ::StandardError, 'Only expected to find one matching entry' if matching_collection_entries.count > 1
+        identifiers << matching_collection_entries.first&.identifier
+      end
+      @possible_collection_ids = identifiers.compact.presence || []
     end
 
     def collections_created?

data/app/models/bulkrax/entry.rb

@@ -58,7 +58,7 @@ module Bulkrax
     # @param data - the data from the metadata file
     # @param path - the path to the metadata file (used by some entries to get the file_paths for import)
     # @return Hash containing the data (the entry build_metadata method will know what to expect in the hash)
-    def self.data_for_entry(_data, _source_id)
+    def self.data_for_entry(_data, _source_id, _parser)
       raise StandardError, 'Not Implemented'
     end
 
@@ -70,12 +70,8 @@ module Bulkrax
       parser&.work_identifier&.to_s || 'source'
     end
 
-    def self.collection_field
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
-      Bulkrax.collection_field_mapping[self.to_s]
+    def self.parent_field(parser)
+      parser.related_parents_parsed_mapping
     end
 
     def build

data/app/models/bulkrax/importer.rb

@@ -125,23 +125,32 @@ module Bulkrax
     end
 
     def import_works
-      self.save if self.new_record? # Object needs to be saved for statuses
-      self.only_updates ||= false
-      parser.create_works
-    rescue StandardError => e
-      status_info(e)
+      import_objects(['work'])
     end
 
     def import_collections
-      self.save if self.new_record? # Object needs to be saved for statuses
-      parser.create_collections
-    rescue StandardError => e
-      status_info(e)
+      import_objects(['collection'])
     end
 
     def import_file_sets
-      self.save if self.new_record? # Object needs to be saved for statuses
-      parser.create_file_sets
+      import_objects(['file_set'])
+    end
+
+    def import_relationships
+      import_objects(['relationship'])
+    end
+
+    def import_objects(types_array = nil)
+      self.only_updates ||= false
+      types = types_array || %w[work collection file_set relationship]
+      if parser.class == Bulkrax::CsvParser
+        parser.create_objects(types)
+      else
+        types.each do |object_type|
+          self.save if self.new_record? # Object needs to be saved for statuses
+          parser.send("create_#{object_type.pluralize}")
+        end
+      end
     rescue StandardError => e
       status_info(e)
     end

data/app/models/bulkrax/oai_entry.rb

@@ -26,10 +26,6 @@ module Bulkrax
     end
 
     def build_metadata
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       self.parsed_metadata = {}
       self.parsed_metadata[work_identifier] = [record.header.identifier]
 

data/app/models/bulkrax/pending_relationship.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class PendingRelationship < ApplicationRecord
+    belongs_to :bulkrax_importer_run, class_name: "::Bulkrax::ImporterRun"
+  end
+end

data/app/models/bulkrax/rdf_entry.rb

@@ -13,11 +13,7 @@ module Bulkrax
       data.predicates.map(&:to_s)
     end
 
-    def self.data_for_entry(data, source_id)
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
+    def self.data_for_entry(data, source_id, parser)
       reader = data
       format = reader.class.format.to_sym
       collections = []
@@ -25,7 +21,7 @@ module Bulkrax
       delete = nil
       data = RDF::Writer.for(format).buffer do |writer|
         reader.each_statement do |statement|
-          collections << statement.object.to_s if collection_field.present? && collection_field == statement.predicate.to_s
+          collections << statement.object.to_s if parent_field(parser).present? && parent_field(parser) == statement.predicate.to_s
           children << statement.object.to_s if related_children_parsed_mapping.present? && related_children_parsed_mapping == statement.predicate.to_s
           delete = statement.object.to_s if /deleted/.match?(statement.predicate.to_s)
           writer << statement
@@ -55,10 +51,6 @@ module Bulkrax
     end
 
     def build_metadata
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       raise StandardError, 'Record not found' if record.nil?
       raise StandardError, "Missing source identifier (#{source_identifier})" if self.raw_metadata[source_identifier].blank?
 

data/app/models/bulkrax/xml_entry.rb

@@ -14,7 +14,7 @@ module Bulkrax
       Nokogiri::XML(open(path)).remove_namespaces!
     end
 
-    def self.data_for_entry(data, source_id)
+    def self.data_for_entry(data, source_id, _parser)
       collections = []
       children = []
       xpath_for_source_id = ".//*[name()='#{source_id}']"
@@ -39,10 +39,6 @@ module Bulkrax
     end
 
     def build_metadata
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       raise StandardError, 'Record not found' if record.nil?
       raise StandardError, "Missing source identifier (#{source_identifier})" if self.raw_metadata[source_identifier].blank?
       self.parsed_metadata = {}

data/app/models/concerns/bulkrax/export_behavior.rb

@@ -26,7 +26,9 @@ module Bulkrax
 
     def write_files
       return if hyrax_record.is_a?(Collection)
-      hyrax_record.file_sets.each do |fs|
+
+      file_sets = hyrax_record.file_set? ? Array.wrap(hyrax_record) : hyrax_record.file_sets
+      file_sets.each do |fs|
         path = File.join(exporter_export_path, 'files')
         FileUtils.mkdir_p(path)
         file = filename(fs)

data/app/models/concerns/bulkrax/has_matchers.rb

@@ -129,10 +129,6 @@ module Bulkrax
     end
 
     def supported_bulkrax_fields
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       @supported_bulkrax_fields ||=
         %W[
           id
@@ -141,22 +137,16 @@ module Bulkrax
           model
           visibility
           delete
-          #{parser.collection_field_mapping}
           #{related_parents_parsed_mapping}
           #{related_children_parsed_mapping}
         ]
     end
 
     def multiple?(field)
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       @multiple_bulkrax_fields ||=
         %W[
           file
           remote_files
-          #{parser.collection_field_mapping}
           #{related_parents_parsed_mapping}
           #{related_children_parsed_mapping}
         ]

data/app/models/concerns/bulkrax/import_behavior.rb

@@ -28,7 +28,8 @@ module Bulkrax
       self.parsed_metadata[related_parents_parsed_mapping].each do |parent_identifier|
         next if parent_identifier.blank?
 
-        CreateRelationshipsJob.perform_later(entry_identifier: self.identifier, parent_identifier: parent_identifier, importer_run: self.last_run)
+        add_parent_to_import_run(parent_identifier, importerexporter.last_run)
+        PendingRelationship.create!(child_id: self.identifier, parent_id: parent_identifier, bulkrax_importer_run_id: importerexporter.last_run.id, order: self.id)
       end
     end
 
@@ -36,10 +37,17 @@ module Bulkrax
       self.parsed_metadata[related_children_parsed_mapping].each do |child_identifier|
         next if child_identifier.blank?
 
-        CreateRelationshipsJob.perform_later(entry_identifier: self.identifier, child_identifier: child_identifier, importer_run: self.last_run)
+        add_parent_to_import_run(self.identifier, importerexporter.last_run)
+        PendingRelationship.create!(parent_id: self.identifier, child_id: child_identifier, bulkrax_importer_run_id: importerexporter.last_run.id, order: self.id)
       end
     end
 
+    def add_parent_to_import_run(parent_id, run)
+      run.parents = [] if run.parents.nil?
+      run.parents << parent_id
+      run.save
+    end
+
     def find_collection_ids
       self.collection_ids
     end
@@ -77,10 +85,6 @@ module Bulkrax
     def add_collections
       return if find_collection_ids.blank?
 
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       self.parsed_metadata['member_of_collections_attributes'] = {}
       find_collection_ids.each_with_index do |c, i|
         self.parsed_metadata['member_of_collections_attributes'][i.to_s] = { id: c }
@@ -88,15 +92,10 @@ module Bulkrax
     end
 
     def factory
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       @factory ||= Bulkrax::ObjectFactory.new(attributes: self.parsed_metadata,
                                               source_identifier_value: identifier,
                                               work_identifier: parser.work_identifier,
-                                              collection_field_mapping: parser.collection_field_mapping,
-                                              related_parents_parsed_mapping: related_parents_parsed_mapping,
+                                              related_parents_parsed_mapping: parser.related_parents_parsed_mapping,
                                               replace_files: replace_files,
                                               user: user,
                                               klass: factory_class,

data/app/models/concerns/bulkrax/importer_exporter_behavior.rb

@@ -20,14 +20,14 @@ module Bulkrax
       (last_imported_at || Time.current) + frequency.to_seconds if schedulable? && last_imported_at.present?
     end
 
-    def increment_counters(index, collection: false, file_set: false)
+    def increment_counters(index, collection: false, file_set: false, work: false)
       # Only set the totals if they were not set on initialization
       importer_run = ImporterRun.find(current_run.id) # make sure fresh
       if collection
         importer_run.total_collection_entries = index + 1 unless parser.collections_total.positive?
       elsif file_set
         importer_run.total_file_set_entries = index + 1 unless parser.file_sets_total.positive?
-      else
+      elsif work
         # TODO: differentiate between work and collection counts for exporters
         importer_run.total_work_entries = index + 1 unless limit.to_i.positive? || parser.total.positive?
       end

data/app/parsers/bulkrax/application_parser.rb

@@ -56,7 +56,7 @@ module Bulkrax
     end
 
     def related_parents_parsed_mapping
-      @related_parents_parsed_mapping ||= get_field_mapping_hash_for('related_parents_field_mapping')&.keys&.first
+      @related_parents_parsed_mapping ||= (get_field_mapping_hash_for('related_parents_field_mapping')&.keys&.first || 'parents')
     end
 
     def related_children_raw_mapping
@@ -64,29 +64,22 @@ module Bulkrax
     end
 
     def related_children_parsed_mapping
-      @related_children_parsed_mapping ||= get_field_mapping_hash_for('related_children_field_mapping')&.keys&.first
+      @related_children_parsed_mapping ||= (get_field_mapping_hash_for('related_children_field_mapping')&.keys&.first || 'children')
     end
 
     def get_field_mapping_hash_for(key)
       return instance_variable_get("@#{key}_hash") if instance_variable_get("@#{key}_hash").present?
 
+      mapping = importerexporter.field_mapping == [{}] ? {} : importerexporter.field_mapping
       instance_variable_set(
         "@#{key}_hash",
-        importerexporter.mapping.with_indifferent_access.select { |_, h| h.key?(key) }
+        mapping&.with_indifferent_access&.select { |_, h| h.key?(key) }
       )
       raise StandardError, "more than one #{key} declared: #{instance_variable_get("@#{key}_hash").keys.join(', ')}" if instance_variable_get("@#{key}_hash").length > 1
 
       instance_variable_get("@#{key}_hash")
     end
 
-    def collection_field_mapping
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
-      Bulkrax.collection_field_mapping[self.entry_class.to_s]&.to_sym || :collection
-    end
-
     def model_field_mappings
       model_mappings = Bulkrax.field_mappings[self.class.to_s]&.dig('model', :from) || []
       model_mappings |= ['model']
@@ -118,6 +111,10 @@ module Bulkrax
       raise StandardError, 'must be defined' if importer?
     end
 
+    def create_relationships
+      raise StandardError, 'must be defined' if importer?
+    end
+
     # Optional, define if using browse everything for file upload
     def retrieve_cloud_files(files); end
 

data/app/parsers/bulkrax/bagit_parser.rb

@@ -39,7 +39,7 @@ module Bulkrax
         path = metadata_path(bag)
         raise StandardError, 'No metadata files were found' if path.blank?
         data = entry_class.read_data(path)
-        data = entry_class.data_for_entry(data, source_identifier)
+        data = entry_class.data_for_entry(data, source_identifier, self)
         data[:file] = bag.bag_files.join('|') unless importerexporter.metadata_only?
         data
       end
@@ -75,7 +75,7 @@ module Bulkrax
         else
           ImportWorkJob.send(perform_method, new_entry.id, current_run.id)
         end
-        increment_counters(index)
+        increment_counters(index, work: true)
       end
       importer.record_status
     rescue StandardError => e
@@ -83,11 +83,7 @@ module Bulkrax
     end
 
     def collections
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
-      records.map { |r| r[collection_field_mapping].split(/\s*[;|]\s*/) if r[collection_field_mapping].present? }.flatten.compact.uniq
+      records.map { |r| r[related_parents_parsed_mapping].split(/\s*[;|]\s*/) if r[related_parents_parsed_mapping].present? }.flatten.compact.uniq
     end
 
     def collections_total

data/app/parsers/bulkrax/csv_parser.rb

@@ -14,18 +14,13 @@ module Bulkrax
       csv_data = entry_class.read_data(file_for_import)
       importer.parser_fields['total'] = csv_data.count
       importer.save
-      @records ||= csv_data.map { |record_data| entry_class.data_for_entry(record_data, nil) }
+      @records ||= csv_data.map { |record_data| entry_class.data_for_entry(record_data, nil, self) }
     end
 
     def collections
-      ActiveSupport::Deprecation.warn(
-        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-      )
       # retrieve a list of unique collections
       records.map do |r|
         collections = []
-        r[collection_field_mapping].split(/\s*[;|]\s*/).each { |title| collections << { title: title, from_collection_field_mapping: true } } if r[collection_field_mapping].present?
         model_field_mappings.each do |model_mapping|
           collections << r if r[model_mapping.to_sym]&.downcase == 'collection'
         end
@@ -85,73 +80,54 @@ module Bulkrax
     end
 
     def create_collections
-      collections.each_with_index do |collection, index|
-        next if collection.blank?
-        break if records.find_index(collection).present? && limit_reached?(limit, records.find_index(collection))
-        ActiveSupport::Deprecation.warn(
-          'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
-          ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
-        )
-
-        ## BEGIN
-        # Add required metadata to collections being imported using the collection_field_mapping, which only have a :title
-        # TODO: Remove once collection_field_mapping is removed
-        metadata = if collection.delete(:from_collection_field_mapping)
-                     uci = unique_collection_identifier(collection)
-                     {
-                       title: collection[:title],
-                       work_identifier => uci,
-                       source_identifier => uci,
-                       visibility: 'open',
-                       collection_type_gid: ::Hyrax::CollectionType.find_or_create_default_collection_type.gid
-                     }
-                   end
-        collection_hash = metadata.presence || collection
-        ## END
-
-        new_entry = find_or_create_entry(collection_entry_class, collection_hash[source_identifier], 'Bulkrax::Importer', collection_hash)
-        increment_counters(index, collection: true)
-        # TODO: add support for :delete option
-        ImportCollectionJob.perform_now(new_entry.id, current_run.id)
-      end
-      importer.record_status
-    rescue StandardError => e
-      status_info(e)
+      create_objects(['collection'])
     end
 
     def create_works
-      works.each_with_index do |work, index|
-        next unless record_has_source_identifier(work, records.find_index(work))
-        break if limit_reached?(limit, records.find_index(work))
-
-        seen[work[source_identifier]] = true
-        new_entry = find_or_create_entry(entry_class, work[source_identifier], 'Bulkrax::Importer', work.to_h)
-        if work[:delete].present?
-          DeleteWorkJob.send(perform_method, new_entry, current_run)
-        else
-          ImportWorkJob.send(perform_method, new_entry.id, current_run.id)
-        end
-        increment_counters(index)
-      end
-      importer.record_status
-    rescue StandardError => e
-      status_info(e)
+      create_objects(['work'])
     end
 
     def create_file_sets
-      file_sets.each_with_index do |file_set, index|
-        next unless record_has_source_identifier(file_set, records.find_index(file_set))
-        break if limit_reached?(limit, records.find_index(file_set))
+      create_objects(['file_set'])
+    end
 
-        new_entry = find_or_create_entry(file_set_entry_class, file_set[source_identifier], 'Bulkrax::Importer', file_set.to_h)
-        ImportFileSetJob.perform_later(new_entry.id, current_run.id)
-        increment_counters(index, file_set: true)
+    def create_relationships
+      create_objects(['relationship'])
+    end
+
+    def create_objects(types_array = nil)
+      (types_array || %w[work collection file_set relationship]).each do |type|
+        if type.eql?('relationship')
+          ScheduleRelationshipsJob.set(wait: 5.minutes).perform_later(importer_id: importerexporter.id)
+          next
+        end
+        send(type.pluralize).each_with_index do |current_record, index|
+          next unless record_has_source_identifier(current_record, records.find_index(current_record))
+          break if limit_reached?(limit, records.find_index(current_record))
+
+          seen[current_record[source_identifier]] = true
+          create_entry_and_job(current_record, type)
+          increment_counters(index, "#{type}": true)
+        end
+        importer.record_status
       end
-      importer.record_status
     rescue StandardError => e
       status_info(e)
     end
 
+    def create_entry_and_job(current_record, type)
+      new_entry = find_or_create_entry(send("#{type}_entry_class"),
+                                       current_record[source_identifier],
+                                       'Bulkrax::Importer',
+                                       current_record.to_h)
+      if current_record[:delete].present?
+        # TODO: create a "Delete" job for file_sets and collections
+        "Bulkrax::Delete#{type.camelize}Job".constantize.send(perform_method, new_entry, current_run)
+      else
+        "Bulkrax::Import#{type.camelize}Job".constantize.send(perform_method, new_entry.id, current_run.id)
+      end
+    end
+
     def write_partial_import_file(file)
       import_filename = import_file_path.split('/').last
       partial_import_filename = "#{File.basename(import_filename, '.csv')}_corrected_entries.csv"
@@ -188,13 +164,13 @@ module Bulkrax
 
       case importerexporter.export_from
       when 'all'
-        @work_ids = ActiveFedora::SolrService.query("has_model_ssim:(#{Hyrax.config.curation_concerns.join(' OR ')}) #{extra_filters}", rows: 2_147_483_647).map(&:id)
-        @collection_ids = ActiveFedora::SolrService.query("has_model_ssim:Collection #{extra_filters}", rows: 2_147_483_647).map(&:id)
-        @file_set_ids = ActiveFedora::SolrService.query("has_model_ssim:FileSet #{extra_filters}", rows: 2_147_483_647).map(&:id)
+        @work_ids = ActiveFedora::SolrService.query("has_model_ssim:(#{Hyrax.config.curation_concerns.join(' OR ')}) #{extra_filters}", method: :post, rows: 2_147_483_647).map(&:id)
+        @collection_ids = ActiveFedora::SolrService.query("has_model_ssim:Collection #{extra_filters}", method: :post, rows: 2_147_483_647).map(&:id)
+        @file_set_ids = ActiveFedora::SolrService.query("has_model_ssim:FileSet #{extra_filters}", method: :post, rows: 2_147_483_647).map(&:id)
       when 'collection'
-        @work_ids = ActiveFedora::SolrService.query("member_of_collection_ids_ssim:#{importerexporter.export_source + extra_filters}", rows: 2_000_000_000).map(&:id)
+        @work_ids = ActiveFedora::SolrService.query("member_of_collection_ids_ssim:#{importerexporter.export_source + extra_filters}", method: :post, rows: 2_000_000_000).map(&:id)
       when 'worktype'
-        @work_ids = ActiveFedora::SolrService.query("has_model_ssim:#{importerexporter.export_source + extra_filters}", rows: 2_000_000_000).map(&:id)
+        @work_ids = ActiveFedora::SolrService.query("has_model_ssim:#{importerexporter.export_source + extra_filters}", method: :post, rows: 2_000_000_000).map(&:id)
       when 'importer'
         set_ids_for_exporting_from_importer
       end
@@ -214,7 +190,7 @@ module Bulkrax
       extra_filters = extra_filters.presence || '*:*'
 
       { :@work_ids => ::Hyrax.config.curation_concerns, :@collection_ids => [::Collection], :@file_set_ids => [::FileSet] }.each do |instance_var, models_to_search|
-        instance_variable_set(instance_var, ActiveFedora::SolrService.get(
+        instance_variable_set(instance_var, ActiveFedora::SolrService.post(
           extra_filters.to_s,
           fq: [
             "#{work_identifier}_sim:(#{complete_entry_identifiers.join(' OR ')})",
@@ -256,6 +232,7 @@ module Bulkrax
     def entry_class
       CsvEntry
     end
+    alias work_entry_class entry_class
 
     def collection_entry_class
       CsvCollectionEntry

data/app/parsers/bulkrax/oai_dc_parser.rb

@@ -102,7 +102,7 @@ module Bulkrax
         else
           ImportWorkJob.send(perform_method, new_entry.id, importerexporter.current_run.id)
         end
-        increment_counters(index)
+        increment_counters(index, work: true)
       end
       importer.record_status
     end

data/app/parsers/bulkrax/xml_parser.rb

@@ -40,14 +40,14 @@ module Bulkrax
           metadata_paths.map do |md|
             # Retrieve all records
             elements = entry_class.read_data(md).xpath("//#{record_element}")
-            r += elements.map { |el| entry_class.data_for_entry(el, source_identifier) }
+            r += elements.map { |el| entry_class.data_for_entry(el, source_identifier, self) }
           end
           # Flatten because we may have multiple records per array
           r.compact.flatten
         elsif parser_fields['import_type'] == 'single'
           metadata_paths.map do |md|
             data = entry_class.read_data(md).xpath("//#{record_element}").first # Take only the first record
-            entry_class.data_for_entry(data, source_identifier)
+            entry_class.data_for_entry(data, source_identifier, self)
           end.compact # No need to flatten because we take only the first record
         end
     end
@@ -94,7 +94,7 @@ module Bulkrax
         else
           ImportWorkJob.send(perform_method, new_entry.id, current_run.id)
         end
-        increment_counters(index)
+        increment_counters(index, work: true)
       end
       importer.record_status
     rescue StandardError => e

data/db/migrate/20220301001839_create_bulkrax_pending_relationships.rb

@@ -0,0 +1,11 @@
+class CreateBulkraxPendingRelationships < ActiveRecord::Migration[5.2]
+  def change
+    create_table :bulkrax_pending_relationships do |t|
+      t.belongs_to :bulkrax_importer_run, foreign_key: true, null: false
+      t.string :parent_id, null: false
+      t.string :child_id, null: false
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20220301020307_add_parents_to_bulkrax_importer_runs.rb

@@ -0,0 +1,5 @@
+class AddParentsToBulkraxImporterRuns < ActiveRecord::Migration[5.1]
+  def change
+    add_column :bulkrax_importer_runs, :parents, :text, array: true
+  end
+end

data/db/migrate/20220303212810_add_order_to_bulkrax_pending_relationships.rb

@@ -0,0 +1,5 @@
+class AddOrderToBulkraxPendingRelationships < ActiveRecord::Migration[5.2]
+  def change
+    add_column :bulkrax_pending_relationships, :order, :integer, default: 0
+  end
+end

data/lib/bulkrax/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bulkrax
-  VERSION = '2.2.4'
+  VERSION = '3.0.0.beta2'
 end

data/lib/bulkrax.rb

@@ -5,11 +5,9 @@ require 'active_support/all'
 
 module Bulkrax
   class << self
-    # TODO: remove collection_field_mapping when releasing v2
     mattr_accessor :parsers,
                    :default_work_type,
                    :default_field_mapping,
-                   :collection_field_mapping,
                    :fill_in_blank_source_identifiers,
                    :related_children_field_mapping,
                    :related_parents_field_mapping,
@@ -35,17 +33,6 @@ module Bulkrax
     self.removed_image_path = Bulkrax::Engine.root.join('spec', 'fixtures', 'removed.png').to_s
     self.server_name = 'bulkrax@example.com'
 
-    # NOTE: Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.
-    #       Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.
-    # TODO: remove collection_field_mapping when releasing v2
-    # Field_mapping for establishing a collection relationship (FROM work TO collection)
-    # This value IS NOT used for OAI, so setting the OAI Entries here will have no effect
-    # The mapping is supplied per Entry, provide the full class name as a string, eg. 'Bulkrax::CsvEntry'
-    # The default value for CSV is collection
-    self.collection_field_mapping = {
-      'Bulkrax::CsvEntry' => 'collection'
-    }
-
     # Hash of Generic field_mappings for use in the view
     # There must be one field_mappings hash per view parial
     # Based on Hyrax CoreMetadata && BasicMetadata

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bulkrax
 version: !ruby/object:Gem::Version
-  version: 2.2.4
+  version: 3.0.0.beta2
 platform: ruby
 authors:
 - Rob Kaufman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-25 00:00:00.000000000 Z
+date: 2022-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -268,6 +268,7 @@ files:
 - app/jobs/bulkrax/import_file_set_job.rb
 - app/jobs/bulkrax/import_work_job.rb
 - app/jobs/bulkrax/importer_job.rb
+- app/jobs/bulkrax/schedule_relationships_job.rb
 - app/mailers/bulkrax/application_mailer.rb
 - app/matchers/bulkrax/application_matcher.rb
 - app/matchers/bulkrax/bagit_matcher.rb
@@ -287,6 +288,7 @@ files:
 - app/models/bulkrax/oai_entry.rb
 - app/models/bulkrax/oai_qualified_dc_entry.rb
 - app/models/bulkrax/oai_set_entry.rb
+- app/models/bulkrax/pending_relationship.rb
 - app/models/bulkrax/rdf_collection_entry.rb
 - app/models/bulkrax/rdf_entry.rb
 - app/models/bulkrax/status.rb
@@ -363,6 +365,9 @@ files:
 - db/migrate/20211220195027_add_file_set_counters_to_importer_runs.rb
 - db/migrate/20220118001339_add_import_attempts_to_entries.rb
 - db/migrate/20220119213325_add_work_counters_to_importer_runs.rb
+- db/migrate/20220301001839_create_bulkrax_pending_relationships.rb
+- db/migrate/20220301020307_add_parents_to_bulkrax_importer_runs.rb
+- db/migrate/20220303212810_add_order_to_bulkrax_pending_relationships.rb
 - lib/bulkrax.rb
 - lib/bulkrax/engine.rb
 - lib/bulkrax/version.rb
@@ -389,9 +394,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.4
 signing_key: