bulkrax 2.3.0 → 3.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 264fedacd4fc13cbd7450068ff6f16317b9ff33e6f28edf48484652fcdf50c0a
-  data.tar.gz: c91b6d74984569513ae567cc879558fbbc5374b6379ca272c744d5be5972ef45
+  metadata.gz: 144e5a05fdf0d22faa759b2f8529ec971af9001f10c8bbe74d705d954b85e048
+  data.tar.gz: 569cdb00a7f533e5b0e234079d5e2ae0996f7c5230675fec158ce62c06a82987
 SHA512:
-  metadata.gz: 501a1a4bae256c70c35524e3a41d46f25c4d464c180355b10ae47ea13acc1ee20c22a1763c4908ce3821162b7ebd7c1c3a4b975f27ce32a9014a50d04c1c1f18
-  data.tar.gz: 63fbe35c7bf2496d46434fc1d1b8775e4d1b3c5c43529ed258d030ec6816d8a89ad7c9e90a9dc73e21e699f7efabee1dc6279d59840defce087eeeb7db023483
+  metadata.gz: 961ef2fcaccad86d47563de89538446a3757b54cd1abbaabe81e2479b902088ea62a06181fa22819e37df52cd6a32ce4a6c52892cd57ef89983b09a8bea403ef
+  data.tar.gz: 432704c4491eef71eb3a3bc4a294d13b9fa4e08b616c031a71510579919cdde96fa06d697f096016858725f6abf6d4a77414b2533f7aaeaa863e9031725f7ce5

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

@@ -22,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
 
@@ -47,7 +44,6 @@ module Bulkrax
       add_visibility
       add_metadata_for_model
       add_rights_statement
-      add_collections
       add_local
 
       self.parsed_metadata
@@ -70,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
@@ -104,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')
@@ -151,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)
@@ -200,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
 
@@ -228,13 +239,9 @@ 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.'
-      )
       return @possible_collection_ids if @possible_collection_ids.present?
 
-      collection_field_mapping = self.class.collection_field
+      collection_field_mapping = self.class.parent_field(parser)
       return [] unless collection_field_mapping.present? && record[collection_field_mapping].present?
 
       identifiers = []

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/importer_run.rb

@@ -4,5 +4,7 @@ module Bulkrax
   class ImporterRun < ApplicationRecord
     belongs_to :importer
     has_many :statuses, as: :runnable, dependent: :destroy
+
+    serialize :parents, Array
   end
 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,16 @@ 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 << parent_id
+      run.save
+    end
+
     def find_collection_ids
       self.collection_ids
     end
@@ -77,10 +84,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 +91,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,89 +80,52 @@ 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))
-
-        ## 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 = add_required_collection_metadata(collection)
-        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
-        if collection.key?(:from_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.'
-          )
-          # When importing collections using the deprecated collection_field_mapping, the collection MUST be created
-          # before the work, so we use #perform_now to make sure that happens. The downside is, if a collection fails
-          # to import, it will stop the rest of the collections from importing successfully.
-          # TODO: Remove once collection_field_mapping is removed
-          ImportCollectionJob.perform_now(new_entry.id, current_run.id)
-        else
-          ImportCollectionJob.perform_later(new_entry.id, current_run.id)
-        end
-      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
+
+    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))
 
-        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)
+          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
 
-    # 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
-    def add_required_collection_metadata(raw_collection_data)
-      return unless raw_collection_data.key?(:from_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.'
-      )
-
-      uci = unique_collection_identifier(raw_collection_data)
-      {
-        title: raw_collection_data[:title],
-        work_identifier => uci,
-        source_identifier => uci,
-        visibility: 'open',
-        collection_type_gid: ::Hyrax::CollectionType.find_or_create_default_collection_type.gid
-      }
+    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)
@@ -274,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/db/migrate/20220330165510_remove_array_true_from_importer_run_parents_column.rb

@@ -0,0 +1,5 @@
+class RemoveArrayTrueFromImporterRunParentsColumn < ActiveRecord::Migration[5.2]
+  def change
+    change_column :bulkrax_importer_runs, :parents, :text, array: false, default: nil
+  end
+end

data/lib/bulkrax/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bulkrax
-  VERSION = '2.3.0'
+  VERSION = '3.0.0.beta3'
 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.3.0
+  version: 3.0.0.beta3
 platform: ruby
 authors:
 - Rob Kaufman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2022-03-30 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,10 @@ 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
+- db/migrate/20220330165510_remove_array_true_from_importer_run_parents_column.rb
 - lib/bulkrax.rb
 - lib/bulkrax/engine.rb
 - lib/bulkrax/version.rb
@@ -389,9 +395,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: