bulkrax 9.5.1 → 10.0.0

data/app/factories/bulkrax/valkyrie_object_factory.rb

@@ -280,11 +280,14 @@ module Bulkrax
     # @param admin_set_id [String, nil] admin set used to resolve contexts
     # @return [Array<String>]
     def self.schema_properties(klass:, admin_set_id: nil)
-      cached_schema_for(klass: klass, admin_set_id: admin_set_id).map { |k| k.name.to_s }
+      entry = schema_cache_entry(klass: klass, admin_set_id: admin_set_id)
+      entry[:properties] ||= entry[:schema].map { |k| k.name.to_s }.freeze
     end
 
     ##
-    # Returns the schema for a model, memoized per (klass, admin_set_id) pair.
+    # Returns the schema for a model, memoized per (tenant, klass, admin_set_id)
+    # for the current request or job only, so a new metadata profile or a
+    # change to an admin set's contexts is picked up without a restart.
     # Delegates to +Hyrax.schema_for+ when available so that context-gated
     # properties are included without Bulkrax knowing about flexibility internals.
     #
@@ -292,16 +295,25 @@ module Bulkrax
     # @param admin_set_id [String, nil]
     # @return [Dry::Types::Hash]
     def self.cached_schema_for(klass:, admin_set_id: nil)
-      @cached_schema_map ||= {}
-      key = [klass.name, admin_set_id].compact.join('|')
-      @cached_schema_map[key] ||=
-        if admin_set_id.present? && defined?(Hyrax) && Hyrax.respond_to?(:schema_for)
-          Hyrax.schema_for(klass: klass, admin_set_id: admin_set_id)
-        else
-          klass.new.singleton_class.schema || klass.schema
-        end
+      schema_cache_entry(klass: klass, admin_set_id: admin_set_id)[:schema]
     end
 
+    def self.schema_cache_entry(klass:, admin_set_id:)
+      tenant = defined?(Apartment::Tenant) ? Apartment::Tenant.current : 'single'
+      Bulkrax::Current.schema_cache ||= {}
+      Bulkrax::Current.schema_cache[[tenant, klass, admin_set_id]] ||= { schema: resolve_schema(klass: klass, admin_set_id: admin_set_id) }
+    end
+    private_class_method :schema_cache_entry
+
+    def self.resolve_schema(klass:, admin_set_id:)
+      if admin_set_id.present? && defined?(Hyrax) && Hyrax.respond_to?(:schema_for)
+        Hyrax.schema_for(klass: klass, admin_set_id: admin_set_id)
+      else
+        klass.new.singleton_class.schema || klass.schema
+      end
+    end
+    private_class_method :resolve_schema
+
     def self.ordered_file_sets_for(object)
       return [] if object.blank?
 
@@ -434,7 +446,7 @@ module Bulkrax
 
       file_attrs = []
       uploads.each_with_index do |f, index|
-        file_attrs << ({ uploaded_file_id: f["id"].to_s, filename: files[index]["file_name"] }).merge(additional_attributes[index])
+        file_attrs << { uploaded_file_id: f["id"].to_s, filename: files[index]["file_name"] }.merge(additional_attributes[index])
       end
       file_attrs.compact.uniq
     end
@@ -501,7 +513,7 @@ module Bulkrax
       @permitted_attributes ||= begin
         bare = base_permitted_attributes + if klass.respond_to?(:schema)
                                              admin_set_id = attributes[:admin_set_id] || attributes['admin_set_id']
-                                             Bulkrax::ValkyrieObjectFactory.schema_properties(klass: klass, admin_set_id: admin_set_id)
+                                             Bulkrax::ValkyrieObjectFactory.schema_properties(klass: klass, admin_set_id: admin_set_id).map(&:to_sym)
                                            else
                                              klass.properties.keys.map(&:to_sym)
                                            end
@@ -590,18 +602,18 @@ module Bulkrax
 
     # @Override Destroy existing files with Hyrax::Transactions
     def destroy_existing_files(object: @object)
-      existing_files = Hyrax.custom_queries.find_child_file_sets(resource: object)
-      return if existing_files.empty?
-
-      existing_files.each do |fs|
+      destroyed_ids = []
+      Hyrax.custom_queries.find_child_file_sets(resource: object).each do |fs|
         transactions["file_set.destroy"]
           .with_step_args("file_set.remove_from_work" => { user: @user },
                           "file_set.delete" => { user: @user })
           .call(fs)
           .value!
+        destroyed_ids << fs.id
       end
+      return if destroyed_ids.empty?
 
-      object.member_ids = object.member_ids.reject { |m| existing_files.detect { |f| f.id == m } }
+      object.member_ids -= destroyed_ids
       object.rendering_ids = []
       object.representative_id = nil
       object.thumbnail_id = nil

data/app/helpers/bulkrax/validation_helper.rb

@@ -17,7 +17,7 @@ module Bulkrax
     end
 
     def check_admin_set
-      return unless defined?(::Hyrax)
+      return unless Bulkrax.hyrax_loaded?
 
       if params[:importer][:admin_set_id].blank?
         params[:importer][:admin_set_id] = Bulkrax.object_factory.default_admin_set_id

data/app/jobs/bulkrax/create_relationships_job.rb

@@ -114,7 +114,7 @@ module Bulkrax
     # We can use Hyrax's lock manager when we have one available.
     # However it's not certain that this is actually working, so to be
     # as safe as possible, we will reload resources before we update.
-    if defined?(::Hyrax)
+    if Bulkrax.hyrax_loaded?
       include Hyrax::Lockable
 
       def conditionally_acquire_lock_for(*args, &block)

data/app/jobs/bulkrax/import_collection_job.rb

@@ -10,8 +10,15 @@ module Bulkrax
       begin
         entry.build
         entry.save!
-        ImporterRun.increment_counter(:processed_records, args[1])
-        ImporterRun.increment_counter(:processed_collections, args[1])
+        # An entry that fails inside #build records the error on itself rather
+        # than raising, so its status is what says whether this run succeeded.
+        if entry.succeeded?
+          ImporterRun.increment_counter(:processed_records, args[1])
+          ImporterRun.increment_counter(:processed_collections, args[1])
+        else
+          ImporterRun.increment_counter(:failed_records, args[1])
+          ImporterRun.increment_counter(:failed_collections, args[1])
+        end
         ImporterRun.decrement_counter(:enqueued_records, args[1]) unless ImporterRun.find(args[1]).enqueued_records <= 0 # rubocop:disable Style/IdenticalConditionalBranches
       rescue => e
         ImporterRun.increment_counter(:failed_records, args[1])

data/app/matchers/bulkrax/application_matcher.rb

@@ -67,10 +67,13 @@ module Bulkrax
     end
 
     def parse_subject(src)
-      string = src.strip.downcase
+      string = src.strip
       return if string.blank?
 
-      string.slice(0, 1).capitalize + string.slice(1..-1)
+      return string.sub(%r{\Ahttps?}i, &:downcase) if string.match?(%r{\Ahttps?://}i)
+
+      downcased = string.downcase
+      downcased.slice(0, 1).capitalize + downcased.slice(1..-1)
     end
 
     def parse_types(src)

data/app/models/bulkrax/csv_entry.rb

@@ -141,7 +141,7 @@ module Bulkrax
 
     def add_metadata_for_model
       if factory_class.present? && factory_class == Bulkrax.collection_model_class
-        add_collection_type_gid if defined?(::Hyrax)
+        add_collection_type_gid if Bulkrax.hyrax_loaded?
         # add any additional collection metadata methods here
       elsif factory_class == Bulkrax.file_model_class
         validate_presence_of_filename!

data/app/models/bulkrax/current.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :schema_cache
+  end
+end

data/app/models/bulkrax/export_scope.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  # A minimal scope adapter that satisfies the Blacklight::SearchBuilder and
+  # Hydra::AccessControlsEnforcement interface for export permission filtering.
+  #
+  # Blacklight::SearchBuilder expects the scope to respond to +blacklight_config+
+  # and +current_ability+. In the Hyrax catalog this is the controller; for
+  # Bulkrax exports a lightweight PORO is sufficient.
+  class ExportScope
+    attr_reader :current_ability
+
+    def initialize(ability)
+      @current_ability = ability
+    end
+
+    def blacklight_config
+      @blacklight_config ||= Blacklight::Configuration.new
+    end
+  end
+end

data/app/models/bulkrax/exporter.rb

@@ -69,7 +69,7 @@ module Bulkrax
     end
 
     def workflow_status_list
-      Sipity::WorkflowState.all.map { |s| [s.name&.titleize, s.name] }.uniq if defined?(::Hyrax)
+      Sipity::WorkflowState.all.map { |s| [s.name&.titleize, s.name] }.uniq if Bulkrax.hyrax_loaded?
     end
 
     # If field_mapping is empty, setup a default based on the export_properties
@@ -84,7 +84,7 @@ module Bulkrax
     end
 
     def export_from_list
-      if defined?(::Hyrax)
+      if Bulkrax.hyrax_loaded?
         [
           [I18n.t('bulkrax.exporter.labels.importer'), 'importer'],
           [I18n.t('bulkrax.exporter.labels.collection'), 'collection'],

data/app/models/bulkrax/importer.rb

@@ -18,7 +18,7 @@ module Bulkrax
     has_many :entries, as: :importerexporter, dependent: :destroy
 
     validates :name, presence: true
-    validates :admin_set_id, presence: true if defined?(::Hyrax)
+    validates :admin_set_id, presence: true if Bulkrax.hyrax_loaded?
     validates :parser_klass, presence: true
 
     delegate :create_parent_child_relationships, :valid_import?, :write_errored_entries_file, :visibility, to: :parser

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  # Concern providing Bulkrax-specific ability methods.
+  #
+  # Include this in your application's Ability class to gain default
+  # implementations of all Bulkrax authorization methods. Override any
+  # method to customize authorization behavior for your application.
+  #
+  # ## Wiring CanCan rules
+  #
+  # Call +bulkrax_default_abilities+ from your Ability's +initialize+ (or add
+  # it to +self.ability_logic+) to register CanCan +can+ rules for all
+  # Bulkrax resources:
+  #
+  #   class Ability
+  #     include Hydra::Ability
+  #     include Bulkrax::AbilityBehavior
+  #     self.ability_logic += [:bulkrax_default_abilities]
+  #   end
+  #
+  # The method uses the four predicate hooks below as guards, so you can
+  # control who gets which rules simply by overriding those predicates.
+  #
+  # Example:
+  #
+  #   class Ability
+  #     include Hydra::Ability
+  #     include Bulkrax::AbilityBehavior
+  #     self.ability_logic += [:bulkrax_default_abilities]
+  #
+  #     # Grant import/export access to users who can create works
+  #     def can_import_works?
+  #       can_create_any_work?
+  #     end
+  #
+  #     def can_export_works?
+  #       can_create_any_work?
+  #     end
+  #
+  #     # Grant admin-level importer access to site admins
+  #     def can_admin_importers?
+  #       current_user.admin?
+  #     end
+  #   end
+  module AbilityBehavior
+    extend ActiveSupport::Concern
+
+    # Returns true if the current user may use importer functionality at all.
+    # Override in your Ability class to customize.
+    def can_import_works?
+      false
+    end
+
+    # Returns true if the current user may use exporter functionality at all.
+    # Override in your Ability class to customize.
+    def can_export_works?
+      false
+    end
+
+    # Returns true if the current user may administer ALL importers —
+    # i.e., view, edit, update, or destroy any importer regardless of ownership.
+    # Defaults to false; override to grant admin access.
+    def can_admin_importers?
+      false
+    end
+
+    # Returns true if the current user may administer ALL exporters —
+    # i.e., view, edit, update, or destroy any exporter regardless of ownership.
+    # Defaults to false; override to grant admin access.
+    def can_admin_exporters?
+      false
+    end
+
+    # Registers CanCan +can+ rules for all Bulkrax resources.
+    #
+    # Call this from your Ability's +initialize+ or add it to
+    # +self.ability_logic+. The predicate hooks above control which rules are
+    # granted; override them to tailor access.
+    #
+    # Rules for Importer and Exporter use hash-form conditions (SQL-generatable)
+    # so they work with +Model.accessible_by(current_ability)+. Rules for Entry
+    # use block-form conditions (checked in Ruby) because authorization must
+    # traverse the parent association — do not call +Entry.accessible_by()+;
+    # scope entries through the parent instead (e.g. +@importer.entries+).
+    def bulkrax_default_abilities
+      # Skip all rules when there is no authenticated user; avoids nil-id bugs
+      # and prevents block rules from matching NULL user_id records.
+      return unless current_user&.id
+
+      # Map Bulkrax-specific non-CRUD actions to their closest CanCan equivalents
+      # so that load_and_authorize_resource can authorize them without requiring
+      # a dedicated `can` declaration for each custom action name.
+      alias_action :entry_table, :importer_table, :exporter_table,
+                   :original_file, :export_errors, :upload_corrected_entries, to: :read
+      alias_action :continue, :upload_corrected_entries_file, to: :update
+
+      grant_importer_abilities
+      grant_exporter_abilities
+    end
+
+    def grant_importer_abilities
+      if can_admin_importers?
+        # Prefer a single unconditional rule for admins.  Older CanCanCan/
+        # ActiveRecord combinations used by the Hyrax 4 appraisal can fail when
+        # accessible_by has to merge unconditional and hash-conditioned rules.
+        can :manage, Bulkrax::Importer
+        can [:read, :update, :destroy], Bulkrax::Entry do |entry|
+          entry.importerexporter.is_a?(Bulkrax::Importer)
+        end
+      elsif can_import_works?
+        can :create, Bulkrax::Importer
+        can [:read, :update, :destroy], Bulkrax::Importer, user_id: current_user.id
+        can [:read, :update, :destroy], Bulkrax::Entry do |entry|
+          entry.importerexporter.is_a?(Bulkrax::Importer) &&
+            entry.importerexporter.user_id == current_user.id
+        end
+      end
+    end
+
+    def grant_exporter_abilities
+      if can_admin_exporters?
+        # Prefer a single unconditional rule for admins.  See importer rule
+        # above for the Hyrax 4 accessible_by compatibility note.
+        can :manage, Bulkrax::Exporter
+        can [:read, :update, :destroy], Bulkrax::Entry do |entry|
+          entry.importerexporter.is_a?(Bulkrax::Exporter)
+        end
+      elsif can_export_works?
+        can :create, Bulkrax::Exporter
+        can [:read, :update, :destroy], Bulkrax::Exporter, user_id: current_user.id
+        can [:read, :update, :destroy], Bulkrax::Entry do |entry|
+          entry.importerexporter.is_a?(Bulkrax::Exporter) &&
+            entry.importerexporter.user_id == current_user.id
+        end
+      end
+    end
+  end
+end

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

@@ -230,7 +230,7 @@ module Bulkrax
     # @return [Array] hyrax fields
     def field_to(field)
       fields = mapping&.map do |key, value|
-        return unless value
+        next unless value
 
         if value['from'].instance_of?(Array)
           key if value['from'].include?(field) || key == field

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

@@ -34,7 +34,7 @@ module Bulkrax
       # TODO: This guard clause is not necessary as we can handle it in the
       # underlying factory.  However, to do that requires adjusting about 7
       # failing specs.  So for now this refactor appears acceptable
-      return unless defined?(::Hyrax)
+      return unless Bulkrax.hyrax_loaded?
       return unless self.class.to_s.include?("Collection")
       factory.add_user_to_collection_permissions(collection: @item, user: user)
     end
@@ -87,7 +87,7 @@ module Bulkrax
     end
 
     def add_admin_set_id
-      return unless defined?(::Hyrax)
+      return unless Bulkrax.hyrax_loaded?
 
       self.parsed_metadata['admin_set_id'] = importerexporter.admin_set_id if self.parsed_metadata['admin_set_id'].blank?
     end
@@ -161,7 +161,7 @@ module Bulkrax
     # @param field [String] name of the controlled property
     # @return [Boolean] provided value is a present, active authority ID for the provided field
     def active_id_for_authority?(value, field)
-      return false unless defined?(::Hyrax)
+      return false unless Bulkrax.hyrax_loaded?
       field_service = ('Hyrax::' + "#{field}_service".camelcase).constantize
       active_authority_ids = field_service.new.active_elements.map { |ae| ae['id'] }
 

data/app/parsers/bulkrax/csv_parser.rb

@@ -37,7 +37,6 @@ module Bulkrax
       @records
     end
 
-    # rubocop:disable Metrics/AbcSize
     def build_records
       @collections = []
       @works = []
@@ -49,11 +48,9 @@ module Bulkrax
             next unless r.key?(model_mapping)
 
             model = r[model_mapping].nil? ? "" : r[model_mapping].strip
-            # TODO: Eventually this should be refactored to us Hyrax.config.collection_model
-            #       We aren't right now because so many Bulkrax users are in between Fedora and Valkyrie
-            if model.casecmp('collection').zero? || model.casecmp('collectionresource').zero?
+            if Bulkrax.collection_model_name?(model)
               @collections << r
-            elsif model.casecmp('fileset').zero? || model.casecmp('hyrax::fileset').zero?
+            elsif Bulkrax.file_model_name?(model)
               @file_sets << r
             else
               @works << r
@@ -69,7 +66,6 @@ module Bulkrax
 
       true
     end
-    # rubocop:enabled Metrics/AbcSize
 
     def collections
       build_records if @collections.nil?
@@ -372,12 +368,17 @@ module Bulkrax
         raise StandardError, "Record references local files but no files directory could be resolved from the import path" if files_dir.nil?
 
         r[file_mapping].split(split_pattern).map do |f|
-          file = File.join(files_dir, f.strip.tr(' ', '_'))
-          if File.exist?(file) # rubocop:disable Style/GuardClause
-            file
-          else
-            raise "File #{file} does not exist"
-          end
+          reference = f.strip
+          # Try the reference as written first, then the space->underscore
+          # variant produced by #remove_spaces_from_filenames. The rename only
+          # rewrites the top level of files/ (see unzip_spec), so nested
+          # attachments keep their spaces on disk and only match as written.
+          file = [reference, reference.tr(' ', '_')].uniq
+                                                    .map { |candidate| File.join(files_dir, candidate) }
+                                                    .find { |candidate| File.exist?(candidate) }
+          raise "File #{File.join(files_dir, reference)} does not exist" if file.nil?
+
+          file
         end
       end.flatten.compact.uniq
     end

data/app/parsers/bulkrax/oai_dc_parser.rb

@@ -71,7 +71,7 @@ module Bulkrax
       metadata = {
         visibility: 'open'
       }
-      metadata[:collection_type_gid] = Hyrax::CollectionType.find_or_create_default_collection_type.to_global_id.to_s if defined?(::Hyrax)
+      metadata[:collection_type_gid] = Hyrax::CollectionType.find_or_create_default_collection_type.to_global_id.to_s if Bulkrax.hyrax_loaded?
 
       collections.each_with_index do |set, index|
         next unless collection_name == 'all' || collection_name == set.spec

data/app/parsers/bulkrax/parser_export_record_set.rb

@@ -120,7 +120,10 @@ module Bulkrax
       #
       # No sense attempting to query for more than the limit.
       def query_kwargs
-        { fl: "id,#{Bulkrax.solr_key_for_member_file_ids}", method: :post, rows: row_limit }
+        base = { fl: "id,#{Bulkrax.solr_key_for_member_file_ids}", method: :post, rows: row_limit }
+        filters = permission_filters
+        return base if filters.empty?
+        base.merge(fq: filters)
       end
 
       # If we have a limit, we need not query beyond that limit
@@ -175,10 +178,25 @@ module Bulkrax
         @file_sets ||= ParserExportRecordSet.in_batches(candidate_file_set_ids) do |batch_of_ids|
           fsq = "has_model_ssim:\"#{Bulkrax.file_model_internal_resource.demodulize}\" AND id:(\"" + batch_of_ids.join('" OR "') + "\")"
           fsq += extra_filters if extra_filters.present?
-          Bulkrax.object_factory.query(
-            fsq,
-            fl: "id", method: :post, rows: batch_of_ids.size
-          )
+          fq = permission_filters
+          kwargs = { fl: "id", method: :post, rows: batch_of_ids.size }
+          kwargs[:fq] = fq unless fq.empty?
+          Bulkrax.object_factory.query(fsq, **kwargs)
+        end
+      end
+
+      def exporting_user
+        importerexporter.user || Bulkrax.fallback_user_for_importer_exporter_processing
+      end
+
+      def permission_filters
+        @permission_filters ||= begin
+          ability = Ability.new(exporting_user)
+          return [] if ability.can_admin_exporters?
+
+          scope   = Bulkrax::ExportScope.new(ability)
+          builder = Bulkrax::ExportSearchBuilder.new(scope)
+          builder.to_h.fetch(:fq, [])
         end
       end
 
@@ -246,7 +264,7 @@ module Bulkrax
           Bulkrax.object_factory.query(
             extra_filters.to_s,
             **query_kwargs.merge(
-              fq: [
+              fq: (query_kwargs[:fq] || []) + [
                 %(#{solr_name(work_identifier)}:("#{ids.join('" OR "')}")),
                 "has_model_ssim:(#{Bulkrax.curation_concern_internal_resources.join(' OR ')})"
               ],
@@ -261,7 +279,7 @@ module Bulkrax
           Bulkrax.object_factory.query(
             "has_model_ssim:#{Bulkrax.collection_model_internal_resource} #{extra_filters}",
             **query_kwargs.merge(
-              fq: [
+              fq: (query_kwargs[:fq] || []) + [
                 %(#{solr_name(work_identifier)}:("#{ids.join('" OR "')}")),
                 "has_model_ssim:#{Bulkrax.collection_model_internal_resource}"
               ],
@@ -280,7 +298,7 @@ module Bulkrax
           Bulkrax.object_factory.query(
             extra_filters,
             **query_kwargs.merge(
-              fq: [
+              fq: (query_kwargs[:fq] || []) + [
                 %(#{solr_name(work_identifier)}:("#{ids.join('" OR "')}")),
                 "has_model_ssim:#{Bulkrax.file_model_internal_resource}"
               ],

data/app/parsers/concerns/bulkrax/csv_parser/csv_template_generation.rb

@@ -14,7 +14,7 @@ module Bulkrax
         # @param args [Hash] Additional arguments passed to output method (e.g., file_path)
         # @return [String] File path (for 'file' output) or CSV string (for 'csv_string' output)
         def generate_template(models: [], output: 'file', admin_set_id: nil, **args)
-          raise NameError, "Hyrax is not defined" unless defined?(::Hyrax)
+          raise NameError, "Hyrax is not defined" unless Bulkrax.hyrax_loaded?
           TemplateContext.new(models: models, admin_set_id: admin_set_id).send("to_#{output}", **args)
         end
       end

data/app/parsers/concerns/bulkrax/csv_parser/csv_validation.rb

@@ -71,8 +71,7 @@ module Bulkrax
           file_key      = resolve_validation_key(mapping_manager, key: 'file',                            default: :file)
 
           csv_data       = parse_validation_rows(raw_csv, source_id_key, parent_key, children_key, file_key)
-          all_models     = csv_data.map { |r| r[:model].to_s }.reject(&:blank?).uniq
-          all_models    |= [Bulkrax.default_work_type] if Bulkrax.default_work_type.present?
+          all_models     = models_to_validate(csv_data, headers)
           field_analyzer = CsvTemplate::FieldAnalyzer.new(mappings, admin_set_id)
           field_metadata = build_validation_field_metadata(all_models, field_analyzer)
 

data/app/parsers/concerns/bulkrax/csv_parser/csv_validation_helpers.rb

@@ -64,7 +64,7 @@ module Bulkrax
         Rails.logger.error("CsvParser.validate_csv: error building valid headers – #{e.message}")
         standard = %w[model source_identifier parents children file]
         model_fields = field_metadata.values.flat_map { |m| m[:properties] }
-                                            .map { |prop| mapping_manager.key_to_mapped_column(prop) }
+        model_fields = model_fields.map { |prop| mapping_manager.key_to_mapped_column(prop) }
         (standard + model_fields).uniq
       end
 
@@ -129,6 +129,23 @@ module Bulkrax
         all_models.each { |model| missing_required << { model: model, field: source_id_key.to_s } }
       end
 
+      # Adding the default work type unconditionally makes every sheet answer
+      # for that model's required fields, so a collection-only sheet gets asked
+      # for properties belonging to a work type it never mentions.
+      def models_to_validate(csv_data, headers)
+        row_models = csv_data.map { |r| r[:model].to_s }.reject(&:blank?).uniq
+        return row_models if Bulkrax.default_work_type.blank?
+        return row_models unless default_work_type_needed?(csv_data, headers)
+
+        row_models | [Bulkrax.default_work_type]
+      end
+
+      def default_work_type_needed?(csv_data, headers)
+        return true unless headers.map(&:to_s).include?('model')
+
+        csv_data.empty? || csv_data.any? { |r| r[:model].blank? }
+      end
+
       # Adds a file-level notice when the model column is absent or every row has a blank
       # model value, indicating that the default work type will be used for all rows.
       # When this notice is present the per-row default_work_type_used warnings are

data/app/parsers/concerns/bulkrax/csv_parser/csv_validation_hierarchy.rb

@@ -36,9 +36,9 @@ module Bulkrax
         model_str = item[:model].to_s
 
         opts = { type: nil, find_record: find_record, parent: parent_split_pattern, child: child_split_pattern }
-        if model_str.casecmp('collection').zero? || model_str.casecmp('collectionresource').zero?
+        if Bulkrax.collection_model_name?(model_str)
           collections << build_item_hash(item, child_to_parents, all_ids, opts.merge(type: 'collection'))
-        elsif model_str.casecmp('fileset').zero? || model_str.casecmp('hyrax::fileset').zero?
+        elsif Bulkrax.file_model_name?(model_str)
           file_sets << { id: item_id, title: item[:raw_row]['title'] || item_id, type: 'file_set' }
         else
           works << build_item_hash(item, child_to_parents, all_ids, opts.merge(type: 'work'))

data/app/search_builders/bulkrax/export_search_builder.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class ExportSearchBuilder < Blacklight::SearchBuilder
+    include Hydra::AccessControlsEnforcement
+
+    self.default_processor_chain = [:add_access_controls_to_solr_params]
+  end
+end

data/app/services/bulkrax/csv_template/column_builder.rb

@@ -43,8 +43,8 @@ module Bulkrax
 
       # When a property is the target of one or more `object:` field mappings,
       # emit each of those mappings' `from:` columns (e.g. redirect_path,
-      # redirect_canonical, redirect_sequence) rather than the bare property
-      # name (redirects). Otherwise fall back to the standard 1:1 mapping.
+      # redirect_display_url) rather than the bare property name (redirects).
+      # Otherwise fall back to the standard 1:1 mapping.
       def columns_for_property(property)
         nested = @service.mapping_manager.object_columns_for(property)
         return nested if nested.any?

data/app/services/bulkrax/csv_template/mapping_manager.rb

@@ -35,16 +35,18 @@ module Bulkrax
 
       # Returns the column names that target a given object name via the
       # `object:` field-mapping pattern. The template generator uses this to
-      # emit the per-child columns (e.g. redirect_path, redirect_canonical,
-      # redirect_sequence) instead of the bare property name (redirects).
-      # Numbering is intentionally omitted — the template shows the column
-      # shape once; CSV rows can repeat the column with numeric suffixes
-      # (e.g. redirect_path_1, redirect_path_2) at import time.
+      # emit the per-child columns (e.g. redirect_path, redirect_display_url)
+      # instead of the bare property name (redirects). Numbering is
+      # intentionally omitted — the template shows the column shape once;
+      # CSV rows can repeat the column with numeric suffixes (e.g.
+      # redirect_path_1, redirect_path_2) at import time.
+      # An import accepts every `from:` alias, but offering them all here would
+      # put two columns for the same field on the template.
       def object_columns_for(object_name)
         @mappings
           .select { |_k, v| v.is_a?(Hash) && v["object"] == object_name }
-          .values
-          .flat_map { |v| Array(v["from"]) }
+          .keys
+          .map { |key| key_to_mapped_column(key) }
           .uniq
       end