bulkrax 1.0.2 → 2.0.0

data/app/models/bulkrax/csv_entry.rb

@@ -14,59 +14,66 @@ module Bulkrax
     def self.read_data(path)
       raise StandardError, 'CSV path empty' if path.blank?
       CSV.read(path,
-               headers: true,
-               header_converters: :symbol,
-               encoding: 'utf-8')
+        headers: true,
+        header_converters: :symbol,
+        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.'
+      )
       # 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]
+      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'
-      # If the children field mapping is not 'children', add 'children' - the parser needs it
-      raw_data[:children] = raw_data[collection_field.to_sym] if raw_data.keys.include?(children_field.to_sym) && children_field != 'children'
       return raw_data
     end
 
-    def self.collection_field
-      Bulkrax.collection_field_mapping[self.class.to_s] || 'collection'
-    end
+    def build_metadata
+      raise StandardError, 'Record not found' if record.nil?
+      raise StandardError, "Missing required elements, missing element(s) are: #{importerexporter.parser.missing_elements(keys_without_numbers(record.keys)).join(', ')}" unless importerexporter.parser.required_elements?(keys_without_numbers(record.keys))
 
-    def self.children_field
-      Bulkrax.parent_child_field_mapping[self.to_s] || 'children'
-    end
+      self.parsed_metadata = {}
+      add_identifier
+      add_metadata_for_model
+      add_visibility
+      add_ingested_metadata
+      add_rights_statement
+      add_collections
+      add_local
 
-    def keys_without_numbers(keys)
-      keys.map { |key| key_without_numbers(key) }
+      self.parsed_metadata
     end
 
-    def key_without_numbers(key)
-      key.gsub(/_\d+/, '').sub(/^\d+_/, '')
+    def add_identifier
+      self.parsed_metadata[work_identifier] = [record[source_identifier]]
     end
 
-    def build_metadata
-      raise StandardError, 'Record not found' if record.nil?
-      raise StandardError, "Missing required elements, missing element(s) are: #{importerexporter.parser.missing_elements(keys_without_numbers(record.keys)).join(', ')}" unless importerexporter.parser.required_elements?(keys_without_numbers(record.keys))
+    def add_metadata_for_model
+      if factory_class == Collection
+        add_collection_type_gid
+      else
+        add_file unless importerexporter.metadata_only?
+        add_admin_set_id
+      end
+    end
 
-      self.parsed_metadata = {}
-      self.parsed_metadata[work_identifier] = [record[source_identifier]]
-      record.each do |key, value|
-        next if key == 'collection'
+    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.'
+      )
+      record.sort.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
-      add_file
-      add_visibility
-      add_rights_statement
-      add_admin_set_id
-      add_collections
-      add_local
-      self.parsed_metadata
     end
 
     def add_file
@@ -86,10 +93,20 @@ module Bulkrax
       self.parsed_metadata[source_identifier] = hyrax_record.send(work_identifier)
       self.parsed_metadata['model'] = hyrax_record.has_model.first
       build_mapping_metadata
-      self.parsed_metadata['collections'] = hyrax_record.member_of_collection_ids.join('; ')
-      unless hyrax_record.is_a?(Collection)
-        self.parsed_metadata['file'] = hyrax_record.file_sets.map { |fs| filename(fs).to_s if filename(fs).present? }.compact.join('; ')
+
+      # 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
+        end
       end
+
+      build_files unless hyrax_record.is_a?(Collection)
       self.parsed_metadata
     end
 
@@ -97,24 +114,51 @@ module Bulkrax
       mapping.each do |key, value|
         next if Bulkrax.reserved_properties.include?(key) && !field_supported?(key)
         next if key == "model"
+        next if value['excluded']
 
         object_key = key if value.key?('object')
         next unless hyrax_record.respond_to?(key.to_s) || object_key.present?
 
-        data = object_key.present? ? hyrax_record.send(value['object']) : hyrax_record.send(key.to_s)
         if object_key.present?
-          next self.parsed_metadata[key] = '' if data.empty?
-          data = data.first if data.is_a?(ActiveTriples::Relation)
+          build_object(value)
+        else
+          build_value(key, value)
+        end
+      end
+    end
+
+    def build_object(value)
+      data = hyrax_record.send(value['object'])
+      return if data.empty?
+
+      data = data.to_a if data.is_a?(ActiveTriples::Relation)
+      object_metadata(Array.wrap(data))
+    end
 
-          object_metadata(data, object_key)
-        elsif data.is_a?(ActiveTriples::Relation)
-          self.parsed_metadata[key] = data.map { |d| prepare_export_data(d) }.join('; ').to_s unless value[:excluded]
+    def build_value(key, value)
+      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
         else
-          self.parsed_metadata[key] = prepare_export_data(data)
+          data.each_with_index do |d, i|
+            self.parsed_metadata["#{key_for_export(key)}_#{i + 1}"] = prepare_export_data(d)
+          end
         end
+      else
+        self.parsed_metadata[key_for_export(key)] = prepare_export_data(data)
       end
     end
 
+    # On export the key becomes the from and the from becomes the destination. It is the opposite of the import because we are moving data the opposite direction
+    # metadata that does not have a specific Bulkrax entry is mapped to the key name, as matching keys coming in are mapped by the csv parser automatically
+    def key_for_export(key)
+      clean_key = key_without_numbers(key)
+      unnumbered_key = mapping[clean_key] ? mapping[clean_key]['from'].first : clean_key
+      # Bring the number back if there is one
+      "#{unnumbered_key}#{key.sub(clean_key, '')}"
+    end
+
     def prepare_export_data(datum)
       if datum.is_a?(ActiveTriples::Resource)
         datum.to_uri.to_s
@@ -123,30 +167,34 @@ module Bulkrax
       end
     end
 
-    def object_metadata(data, object_key)
-      data = convert_to_hash(data)
+    def object_metadata(data)
+      data = data.map { |d| eval(d) }.flatten # rubocop:disable Security/Eval
 
       data.each_with_index do |obj, index|
-        next unless obj[object_key]
-
-        next self.parsed_metadata["#{object_key}_#{index + 1}"] = prepare_export_data(obj[object_key]) unless obj[object_key].is_a?(Array)
-
-        obj[object_key].each_with_index do |_nested_item, nested_index|
-          self.parsed_metadata["#{object_key}_#{index + 1}_#{nested_index + 1}"] = prepare_export_data(obj[object_key][nested_index])
+        next if obj.nil?
+        # allow the object_key to be valid whether it's a string or symbol
+        obj = obj.with_indifferent_access
+
+        obj.each_key do |key|
+          if obj[key].is_a?(Array)
+            obj[key].each_with_index do |_nested_item, nested_index|
+              self.parsed_metadata["#{key_for_export(key)}_#{index + 1}_#{nested_index + 1}"] = prepare_export_data(obj[key][nested_index])
+            end
+          else
+            self.parsed_metadata["#{key_for_export(key)}_#{index + 1}"] = prepare_export_data(obj[key])
+          end
         end
       end
     end
 
-    def convert_to_hash(data)
-      # converts data from `'[{}]'` to `[{}]`
-      gsub_data = data.gsub(/\[{/, '{')
-                      .gsub(/}\]/, '}')
-                      .gsub('=>', ':')
-                      .gsub(/},\s?{/, "}},{{")
-                      .split("},{")
-      gsub_data = [gsub_data] if gsub_data.is_a?(String)
-
-      return gsub_data.map { |d| JSON.parse(d) }
+    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('; ')
+      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?
+        end
+      end
     end
 
     # In order for the existing exported hyrax_record, to be updated by a re-import
@@ -167,18 +215,28 @@ module Bulkrax
       Bulkrax::CsvMatcher
     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 || []
+    end
+
     def collections_created?
-      return true if record[self.class.collection_field].blank?
-      record[self.class.collection_field].split(/\s*[:;|]\s*/).length == self.collection_ids.length
+      possible_collection_ids.length == self.collection_ids.length
     end
 
-    def find_or_create_collection_ids
+    def find_collection_ids
       return self.collection_ids if collections_created?
-      valid_system_id(Collection)
-      if record[self.class.collection_field].present?
-        record[self.class.collection_field].split(/\s*[:;|]\s*/).each do |collection|
-          c = find_collection(collection)
-          self.collection_ids << c.id unless c.blank? || self.collection_ids.include?(c.id)
+      if possible_collection_ids.present?
+        possible_collection_ids.each do |collection_id|
+          c = find_collection(collection_id)
+          skip = c.blank? || self.collection_ids.include?(c.id)
+          self.collection_ids << c.id unless skip
         end
       end
       self.collection_ids

data/app/models/bulkrax/entry.rb

@@ -23,12 +23,22 @@ module Bulkrax
 
     attr_accessor :all_attrs
 
-    delegate :parser, :mapping, :replace_files, :update_files, to: :importerexporter
+    delegate :parser,
+      :mapping,
+      :replace_files,
+      :update_files,
+      :keys_without_numbers,
+      :key_without_numbers,
+      to: :importerexporter
 
     delegate :client,
-             :collection_name,
-             :user,
-             to: :parser
+      :collection_name,
+      :user,
+      :related_parents_raw_mapping,
+      :related_parents_parsed_mapping,
+      :related_children_raw_mapping,
+      :related_children_parsed_mapping,
+      to: :parser
 
     # Retrieve fields from the file
     # @param data - the source data
@@ -61,13 +71,13 @@ module Bulkrax
     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]
     end
 
-    def self.children_field
-      Bulkrax.parent_child_field_mapping[self.to_s]
-    end
-
     def build
       return if type.nil?
       self.save if self.new_record? # must be saved for statuses
@@ -96,6 +106,7 @@ module Bulkrax
     end
 
     def find_collection(collection_identifier)
+      return unless Collection.properties.keys.include?(work_identifier)
       Collection.where(
         work_identifier => collection_identifier
       ).detect { |m| m.send(work_identifier).include?(collection_identifier) }

data/app/models/bulkrax/exporter.rb

@@ -14,7 +14,7 @@ module Bulkrax
     validates :name, presence: true
     validates :parser_klass, presence: true
 
-    delegate :write, :create_from_collection, :create_from_importer, :create_from_worktype, to: :parser
+    delegate :write, :create_from_collection, :create_from_importer, :create_from_worktype, :create_from_all, to: :parser
 
     def export
       current_run && setup_export_path
@@ -25,6 +25,8 @@ module Bulkrax
         create_from_importer
       when 'worktype'
         create_from_worktype
+      when 'all'
+        create_from_all
       end
     rescue StandardError => e
       status_info(e)
@@ -77,7 +79,8 @@ module Bulkrax
       [
         [I18n.t('bulkrax.exporter.labels.importer'), 'importer'],
         [I18n.t('bulkrax.exporter.labels.collection'), 'collection'],
-        [I18n.t('bulkrax.exporter.labels.worktype'), 'worktype']
+        [I18n.t('bulkrax.exporter.labels.worktype'), 'worktype'],
+        [I18n.t('bulkrax.exporter.labels.all'), 'all']
       ]
     end
 
@@ -105,18 +108,22 @@ module Bulkrax
     end
 
     def exporter_export_path
-      @exporter_export_path ||= File.join(Bulkrax.export_path, self.id.to_s, self.exporter_runs.last.id.to_s)
+      @exporter_export_path ||= File.join(parser.base_path('export'), self.id.to_s, self.exporter_runs.last.id.to_s)
     end
 
     def exporter_export_zip_path
-      @exporter_export_zip_path ||= File.join(Bulkrax.export_path, "export_#{self.id}_#{self.exporter_runs.last.id}.zip")
+      @exporter_export_zip_path ||= File.join(parser.base_path('export'), "export_#{self.id}_#{self.exporter_runs.last.id}.zip")
     rescue
-      @exporter_export_zip_path ||= File.join(Bulkrax.export_path, "export_#{self.id}_0.zip")
+      @exporter_export_zip_path ||= File.join(parser.base_path('export'), "export_#{self.id}_0.zip")
     end
 
     def export_properties
       properties = Hyrax.config.registered_curation_concern_types.map { |work| work.constantize.properties.keys }.flatten.uniq.sort
       properties.reject { |prop| Bulkrax.reserved_properties.include?(prop) }
     end
+
+    def metadata_only?
+      export_type == 'metadata'
+    end
   end
 end

data/app/models/bulkrax/importer.rb

@@ -18,8 +18,7 @@ module Bulkrax
     validates :admin_set_id, presence: true
     validates :parser_klass, presence: true
 
-    delegate :valid_import?, :create_parent_child_relationships,
-             :write_errored_entries_file, :visibility, to: :parser
+    delegate :valid_import?, :write_errored_entries_file, :visibility, to: :parser
 
     attr_accessor :only_updates, :file_style, :file
     attr_writer :current_run
@@ -97,7 +96,11 @@ module Bulkrax
     end
 
     def current_run
-      @current_run ||= self.importer_runs.create!(total_work_entries: self.limit || parser.total, total_collection_entries: parser.collections_total)
+      @current_run ||= if file? && zip?
+                         self.importer_runs.create!
+                       else
+                         self.importer_runs.create!(total_work_entries: self.limit || parser.works_total, total_collection_entries: parser.collections_total)
+                       end
     end
 
     def last_run
@@ -149,11 +152,11 @@ module Bulkrax
 
     # If the import data is zipped, unzip it to this path
     def importer_unzip_path
-      @importer_unzip_path ||= File.join(Bulkrax.import_path, "import_#{path_string}")
+      @importer_unzip_path ||= File.join(parser.base_path, "import_#{path_string}")
     end
 
     def errored_entries_csv_path
-      @errored_entries_csv_path ||= File.join(Bulkrax.import_path, "import_#{path_string}_errored_entries.csv")
+      @errored_entries_csv_path ||= File.join(parser.base_path, "import_#{path_string}_errored_entries.csv")
     end
 
     def path_string
@@ -161,5 +164,9 @@ module Bulkrax
     rescue
       "#{self.id}_#{self.created_at.strftime('%Y%m%d%H%M%S')}"
     end
+
+    def metadata_only?
+      parser.parser_fields['metadata_only'] == true
+    end
   end
 end

data/app/models/bulkrax/oai_entry.rb

@@ -26,6 +26,10 @@ 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]
 
@@ -56,7 +60,7 @@ module Bulkrax
     # Retrieve list of collections for the entry; add to collection_ids
     # If OAI-PMH doesn't return setSpec in the headers for GetRecord, use parser.collection_name
     #   in this case, if 'All' is selected, records will not be added to a collection.
-    def find_or_create_collection_ids
+    def find_collection_ids
       return self.collection_ids if collections_created?
       if sets.blank? || parser.collection_name != 'all'
         # c = Collection.where(Bulkrax.system_identifier_field => importerexporter.unique_collection_identifier(parser.collection_name)).first

data/app/models/bulkrax/rdf_entry.rb

@@ -14,6 +14,10 @@ module Bulkrax
     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.'
+      )
       reader = data
       format = reader.class.format.to_sym
       collections = []
@@ -22,7 +26,7 @@ module Bulkrax
       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
-          children << statement.object.to_s if children_field.present? && children_field == 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
         end
@@ -37,12 +41,13 @@ module Bulkrax
       }
     end
 
-    def self.collection_field
-      Bulkrax.collection_field_mapping[self.to_s]
-    end
+    def self.related_children_parsed_mapping
+      return @related_children_parsed_mapping if @related_children_parsed_mapping.present?
+
+      rdf_related_children_field_mapping = Bulkrax.field_mappings['Bulkrax::RdfParser']&.select { |_, h| h.key?('related_children_field_mapping') }
+      return if rdf_related_children_field_mapping.blank?
 
-    def self.children_field
-      Bulkrax.parent_child_field_mapping[self.to_s]
+      @related_children_parsed_mapping = rdf_related_children_field_mapping&.keys&.first
     end
 
     def record
@@ -50,6 +55,10 @@ 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?
 
@@ -76,7 +85,7 @@ module Bulkrax
       self.raw_metadata['collection'].length == self.collection_ids.length
     end
 
-    def find_or_create_collection_ids
+    def find_collection_ids
       return self.collection_ids if collections_created?
       if self.raw_metadata['collection'].present?
         self.raw_metadata['collection'].each do |collection|

data/app/models/bulkrax/xml_entry.rb

@@ -39,6 +39,10 @@ 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

@@ -40,13 +40,13 @@ module Bulkrax
       end
     end
 
-    # Append the file_set id to ensure a unique filename
+    # Prepend the file_set id to ensure a unique filename
     def filename(file_set)
       return if file_set.original_file.blank?
       fn = file_set.original_file.file_name.first
       mime = Mime::Type.lookup(file_set.original_file.mime_type)
       ext_mime = MIME::Types.of(file_set.original_file.file_name).first
-      if fn.include?(file_set.id)
+      if fn.include?(file_set.id) || importerexporter.metadata_only?
         return fn if mime.to_s == ext_mime.to_s
         return "#{fn}.#{mime.to_sym}"
       else

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

@@ -43,7 +43,6 @@ module Bulkrax
 
         value = if matcher
                   result = matcher.result(self, node_content)
-                  next unless result
                   matched_metadata(multiple, name, result, object_multiple)
                 elsif multiple
                   Rails.logger.info("Bulkrax Column automatically matched #{node_name}, #{node_content}")
@@ -53,12 +52,20 @@ module Bulkrax
                   single_metadata(node_content)
                 end
 
-        set_parsed_data(object_multiple, object_name, name, index, value) if value
+        object_name.present? ? set_parsed_object_data(object_multiple, object_name, name, index, value) : set_parsed_data(name, value)
       end
     end
 
-    def set_parsed_data(object_multiple, object_name, name, index, value)
+    def set_parsed_data(name, value)
+      return parsed_metadata[name] = value unless multiple?(name)
+
+      parsed_metadata[name] ||= []
+      parsed_metadata[name] += Array.wrap(value).flatten
+    end
+
+    def set_parsed_object_data(object_multiple, object_name, name, index, value)
       if object_multiple
+        index ||= 0
         parsed_metadata[object_name][index] ||= {}
         parsed_metadata[object_name][index][name] ||= []
         if value.is_a?(Array)
@@ -66,20 +73,13 @@ module Bulkrax
         else
           parsed_metadata[object_name][index][name] = value
         end
-      elsif object_name
+      else
         parsed_metadata[object_name][name] ||= []
         if value.is_a?(Array)
           parsed_metadata[object_name][name] += value
         else
           parsed_metadata[object_name][name] = value
         end
-      else
-        parsed_metadata[name] ||= []
-        if value.is_a?(Array)
-          parsed_metadata[name] += value
-        else
-          parsed_metadata[name] = value
-        end
       end
     end
 
@@ -124,12 +124,43 @@ module Bulkrax
       field = field.gsub('_attributes', '')
 
       return false if excluded?(field)
-      return true if ['collections', 'file', 'remote_files', 'model', 'delete'].include?(field)
+      return true if supported_bulkrax_fields.include?(field)
       return factory_class.method_defined?(field) && factory_class.properties[field].present?
     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
+          file
+          remote_files
+          model
+          delete
+          #{parser.collection_field_mapping}
+          #{related_parents_parsed_mapping}
+          #{related_children_parsed_mapping}
+        ]
+    end
+
     def multiple?(field)
-      return true if field == 'file' || field == 'remote_files' || field == '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.'
+      )
+      @multiple_bulkrax_fields ||=
+        %W[
+          file
+          remote_files
+          #{parser.collection_field_mapping}
+          #{related_parents_parsed_mapping}
+          #{related_children_parsed_mapping}
+        ]
+
+      return true if @multiple_bulkrax_fields.include?(field)
       return false if field == 'model'
 
       field_supported?(field) && factory_class&.properties&.[](field)&.[]('multiple')