hyrax 5.2.0 → 5.3.0

data/app/forms/hyrax/forms/resource_form.rb

@@ -26,6 +26,8 @@ module Hyrax
         end
       end
 
+      include BasedNearFieldBehavior
+      include CompoundFieldBehavior
       class_attribute :model_class
 
       property :human_readable_type, writable: false
@@ -42,25 +44,87 @@ module Hyrax
       # @see https://github.com/samvera/valkyrie/wiki/Optimistic-Locking
       property :version, virtual: true, prepopulator: LockKeyPrepopulator
 
+      # Wire validators with `attributes:` through `validation { ... }` rather
+      # than the bare `validates_with`. Reform's `validates_with` shim closes
+      # over the args array, so the options hash (`{attributes: [:foo]}`) is
+      # shared across heritage replays. ActiveModel mutates that hash on each
+      # call (`options[:class] = self`, then `options.delete(:attributes)`
+      # inside `EachValidator#initialize`). The first replay leaves the hash
+      # without `:attributes`; the second replay raises
+      # `:attributes cannot be blank` and the subclass crashes at load time.
+      # Wrapping in `validation(name: :default, inherit: true) { ... }` rebuilds
+      # the literal options hash on every replay so each subclass gets its own
+      # clean copy. This pattern applies to *any* `validates_with` that takes
+      # an `attributes:` keyword.
+
       ##
       # @api public
       #
       # Forms should be initialized with an explicit +resource:+ parameter to
       # match indexers.
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def initialize(deprecated_resource = nil, resource: nil)
+        r = resource || deprecated_resource
+        if r.flexible?
+          self.class.deserializer_class = nil # need to reload this on first use after schema is loaded
+          singleton_class.schema_definitions = self.class.definitions
+          contexts = r.respond_to?(:contexts) ? r.contexts : nil
+          current_schema_fields = Hyrax::Schema.m3_schema_loader.form_definitions_for(schema: r.class.name, version: Hyrax::FlexibleSchema.current_schema_id, contexts: contexts)
+          current_schema_fields.each do |field_name, options|
+            singleton_class.property field_name.to_sym, options.merge(display: options.fetch(:display, true), default: [])
+          end
+        end
+
         if resource.nil?
           if !deprecated_resource.nil?
             Deprecation.warn "Initializing Valkyrie forms without an explicit resource parameter is deprecated. Pass the resource with `resource:` instead."
+            # Remove form definitions for attributes the model doesn't support,
+            # mirroring the cleanup in the resource: keyword path below.
+            if deprecated_resource.respond_to?(:flexible?) && deprecated_resource.flexible?
+              to_remove = singleton_class.definitions.select { |k, v| !deprecated_resource.respond_to?(k) && v.instance_variable_get("@options")[:display] }
+              to_remove.keys.each { |removed_field| singleton_class.definitions.delete(removed_field) }
+            end
             super(deprecated_resource)
           else
             super()
           end
         else
+          # make a new resource with all of the existing attributes
+          if resource.flexible?
+            hash = resource.attributes.dup
+            hash[:schema_version] = Hyrax::FlexibleSchema.current_schema_id
+            resource = resource.class.new(hash)
+            # find any fields removed by the current schema
+            current_field_keys = current_schema_fields.keys.map(&:to_s)
+            to_remove = singleton_class.definitions.select { |k, v| !current_field_keys.include?(k.to_s) && v.instance_variable_get("@options")[:display] }
+            to_remove.keys.each do |removed_field|
+              singleton_class.definitions.delete(removed_field)
+            end
+          end
+
           super(resource)
         end
       end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       class << self
+        def inherited(subclass)
+          # Field Behaviors must be prepended onto every subclass so their
+          # `deserialize!` overrides land above Reform's base method on the
+          # ancestor chain. Each behavior gates itself internally and is a
+          # no-op when its feature is off or its property isn't on the
+          # subclass's model.
+          subclass.prepend(BasedNearFieldBehavior)
+          subclass.prepend(RedirectsFieldBehavior)
+          super
+        end
+
+        def check_if_flexible(model)
+          return unless model.flexible?
+          include FlexibleFormBehavior
+          include Hyrax::FormFields(model.to_s, definition_loader: Hyrax::Schema.m3_schema_loader)
+        end
+
         ##
         # @api public
         #
@@ -69,11 +133,12 @@ module Hyrax
         # @example
         #   monograph  = Monograph.new
         #   change_set = Hyrax::Forms::ResourceForm.for(resource: monograph)
-        def for(deprecated_resource = nil, resource: nil)
+        def for(deprecated_resource = nil, resource: nil, admin_set_id: nil)
           if resource.nil? && !deprecated_resource.nil?
             Deprecation.warn "Initializing Valkyrie forms without an explicit resource parameter is deprecated. Pass the resource with `resource:` instead."
-            return self.for(resource: deprecated_resource)
+            return self.for(resource: deprecated_resource, admin_set_id: admin_set_id)
           end
+          apply_admin_set_contexts(resource: resource, admin_set_id: admin_set_id)
           klass = "#{resource.class.name}Form".safe_constantize
           klass ||= Hyrax::Forms::ResourceForm(resource.class)
           begin
@@ -84,10 +149,23 @@ module Hyrax
           end
         end
 
+        private
+
+        def apply_admin_set_contexts(resource:, admin_set_id:)
+          return if admin_set_id.blank?
+          return unless resource.respond_to?(:flexible?) && resource.flexible?
+          admin_set = Hyrax.query_service.find_by(id: admin_set_id)
+          return unless admin_set&.respond_to?(:contexts)
+          contexts = Array(admin_set.contexts)
+          resource.contexts = contexts if contexts.present?
+        rescue Valkyrie::Persistence::ObjectNotFoundError
+          nil
+        end
+
         ##
         # @return [Array<Symbol>] list of required field names as symbols
         def required_fields
-          definitions
+          schema_definitions
             .select { |_, definition| definition[:required] }
             .keys.map(&:to_sym)
         end
@@ -98,14 +176,27 @@ module Hyrax
         # @return [Array<Symbol>] list of required field names as symbols
         def required_fields=(fields)
           fields = fields.map(&:to_s)
-          raise(KeyError) unless fields.all? { |f| definitions.key?(f) }
+          raise(KeyError) unless fields.all? { |f| schema_definitions.key?(f) }
 
-          fields.each { |field| definitions[field].merge!(required: true) }
+          fields.each { |field| schema_definitions[field].merge!(required: true) }
 
           required_fields
         end
-      end
 
+        def schema_definitions
+          @definitions
+        end
+
+        def schema_definitions=(values)
+          @definitions = values
+        end
+
+        def expose_class
+          @expose_class = Class.new(Disposable::Expose).from(schema_definitions.values)
+        end
+
+        public :expose_class, :required_fields, :required_fields=, :schema_definitions, :schema_definitions=
+      end
       ##
       # @param [#to_s] attr
       # @param [Object] value
@@ -127,9 +218,12 @@ module Hyrax
       # @return [Array<Symbol>] terms for display 'above-the-fold', or in the most
       #   prominent form real estate
       def primary_terms
-        _form_field_definitions
-          .select { |_, definition| definition[:primary] }
-          .keys.map(&:to_sym)
+        terms = _form_field_definitions
+                .select { |_, definition| definition[:primary] }
+                .keys.map(&:to_sym)
+
+        terms = [:schema_version, :contexts] + terms if model.flexible?
+        terms
       end
 
       ##
@@ -146,10 +240,16 @@ module Hyrax
         secondary_terms.any?
       end
 
+      delegate :flexible?, to: :model
+
       private
 
       def _form_field_definitions
-        self.class.definitions
+        if model.flexible?
+          singleton_class.schema_definitions
+        else
+          self.class.definitions
+        end
       end
     end
   end

data/app/forms/hyrax/forms.rb

@@ -13,6 +13,7 @@ module Hyrax
     def self.PcdmObjectForm(work_class) # rubocop:disable Naming/MethodName
       Class.new(Hyrax::Forms::PcdmObjectForm) do
         self.model_class = work_class
+        include Hyrax::FormFields(:core_metadata) if work_class.ancestors.detect { |k| k.inspect == "Hyrax::Schema(core_metadata)" }
 
         ##
         # @return [String]

data/app/helpers/hyrax/attributes_helper.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module AttributesHelper
+    def view_options_for(presenter)
+      model_name = presenter.model.model_name.klass.to_s
+      if presenter.respond_to?(:flexible?) && presenter.flexible?
+        Hyrax::Schema.m3_schema_loader.view_definitions_for(schema: model_name, version: presenter.solr_document.schema_version, contexts: presenter.solr_document.contexts)
+      else
+        view_options_without_flexibility(presenter, model_name)
+      end
+    end
+
+    def view_options_without_flexibility(presenter, model_name)
+      model = presenter.model
+      schema = schema(model)
+
+      # no schema found for given model - try a few more fallbacks
+
+      # if wings is enabled we may be able to use the model registry to find the new model
+      if schema.nil? && !Hyrax.config.disable_wings
+        new_model = Wings::ModelRegistry.reverse_lookup(model)
+        schema = schema(new_model) if new_model
+      end
+      # Check if the model has a resource version
+      if schema.nil?
+        new_model = "#{model_name}Resource".safe_constantize
+        schema = schema(new_model) if new_model
+      end
+      # If we still don't have a schema, assume we have a pre-valkyrie model
+      if schema.nil?
+        if model.respond_to?(:local_attributes)
+          return model.local_attributes
+        else
+          return []
+        end
+      end
+
+      Hyrax::Schema.simple_schema_loader.view_definitions_for(schema:)
+    end
+
+    # @param [String] model's class name
+    # @return [Hash] the schema for the model or nil if not found
+    def schema(model)
+      return nil unless model.present?
+
+      # If this is an ActiveFedoraDummyModel, get the schema from the actual model class
+      if model.is_a?(Hyrax::ActiveFedoraDummyModel)
+        actual_model = model.instance_variable_get(:@model)
+        return schema(actual_model) if actual_model
+      end
+
+      # using respond_to? check because try? does not succeed with Dry::Types object that is returned by schema method
+      return nil unless model.respond_to?(:schema)
+      model.schema
+    end
+
+    # @param [String] field name
+    # @param [Hash<Hash>] a nested hash of view options...
+    #        {:render_term=>:based_near_label, :label=>{"en"=>"Title", "es"=>"Título"}, :html_dl=>true}
+    # @return [String] the field name to be used for rendering
+    def conform_field(field_name, options_hash)
+      options_hash&.with_indifferent_access&.fetch('render_term', nil) || field_name
+    end
+
+    # @param [String] field name
+    # @param [Hash<Hash>] a nested hash of view options...
+    #        {:label=>{"en"=>"Title", "es"=>"Título"}, :html_dl=>true}
+    # @return [Hash] the transformed options for the field
+    def conform_options(field_name, view_options)
+      hash_of_locales = view_options.delete(:display_label) || {}
+
+      if hash_of_locales.present?
+        view_options[:label] = hash_of_locales[locale] || hash_of_locales[:default]
+      else
+        view_options[:label] = (view_options[:render_term] || field_name).to_s
+      end
+      field = view_options[:label]
+      translate = I18n.t(field, default: field) if field.match(/\./)
+      if translate && translate != field
+        view_options[:label] = translate
+      else
+        view_options[:label] = field_label(
+          :"blacklight.search.fields.index.#{field}",
+          :"blacklight.search.fields.show.#{field}",
+          :"blacklight.search.fields.#{field}",
+          field.to_s.humanize
+        )
+      end
+      view_options[:base_url] = request.base_url if respond_to?(:request) && request.respond_to?(:base_url)
+      view_options
+    end
+
+    # Returns true when the field should render on the work show page.
+    # Honors these view options:
+    #   * `show_page: false` — suppresses the field on the show page for everyone.
+    #   * `admin_only: true` — only visible to admins.
+    #   * `editor_only: true` — only visible to users the presenter reports as editors.
+    # Setting both `admin_only` and `editor_only` is effectively equivalent to
+    # `admin_only` alone: admins are editors of every record, so they pass both
+    # guards, but a plain editor of the record still fails the admin guard.
+    def field_visible?(view_options, presenter)
+      return false if view_options[:show_page] == false
+      return false if view_options[:admin_only] && !current_user&.admin?
+      return false if view_options[:editor_only] && !presenter.try(:editor?)
+      true
+    end
+  end
+end

data/app/helpers/hyrax/blacklight_override.rb

@@ -5,5 +5,31 @@ module Hyrax
     def application_name
       t('hyrax.product_name', default: super)
     end
+
+    # rubocop:disable Metrics/MethodLength
+    def index_field_label(document, field)
+      field_config = index_fields(document)[field]
+      return resolve_label(field_config) if field_config&.custom_label || field_config&.label&.respond_to?(:call)
+
+      translate = I18n.t(field_config.label, default: field_config.label) if field_config&.label&.match(/\./)
+      if translate && translate != field_config.label
+        field_label(translate, field_config.label, field.to_s.humanize)
+      else
+        field_label(
+          :"blacklight.search.fields.index.#{field}",
+          :"blacklight.search.fields.show.#{field}",
+          :"blacklight.search.fields.#{field}",
+          (field_config.label if field_config),
+            field.to_s.humanize
+        )
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    def resolve_label(field_config)
+      field_config.label.respond_to?(:call) ? field_config.label.call : field_config.label
+    end
   end
 end

data/app/helpers/hyrax/collections_helper.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 module Hyrax
   module CollectionsHelper # rubocop:disable Metrics/ModuleLength
+    include Hyrax::RedirectsTabHelper
+
     ##
     # @since 3.1.0
     # @return [Array<SolrDocument>]

data/app/helpers/hyrax/file_set_form_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module FileSetFormHelper
+    def render_transcript_ids_field?(file_set)
+      return unless file_set.persisted?
+      return if @parent.nil?
+      case file_set
+      when ActiveFedora::Base
+        file_set.video? || file_set.audio?
+      when Valkyrie::Resource
+        service = Hyrax::FileSetTypeService.new(file_set: file_set)
+        service.video? || service.audio?
+      end
+    end
+
+    def transcript_ids_select_options
+      options = Forms::FileSetForm.available_transcripts(parent: @parent, current_ability: current_ability)
+      options.each_with_object({}) do |doc, hash|
+        hash[doc.title_or_label] = doc.id.to_s
+      end
+    end
+  end
+end

data/app/helpers/hyrax/hyrax_helper_behavior.rb

@@ -19,6 +19,34 @@ module Hyrax
     include Hyrax::WorkFormHelper
     include Hyrax::WorkflowsHelper
     include Hyrax::FacetsHelper
+    include Hyrax::AttributesHelper
+    include Hyrax::PermalinkHelper
+    include Hyrax::WorksHelper
+    include Hyrax::FileSetFormHelper
+
+    ##
+    # @return [Array<String>] the list of admin sets available for creating works for this user
+    def available_admin_sets_for_creating_works(ability:)
+      return [] unless Flipflop.assign_admin_set?
+      return [] unless ability
+
+      source_ids = Hyrax::Collections::PermissionsService.source_ids_for_deposit(ability:, source_type: 'admin_set')
+
+      admin_sets_list = Hyrax.query_service.find_many_by_ids(ids: source_ids).map do |source|
+        [source.title.first, source.id]
+      end
+
+      # Sorts the default admin set to be first, then the rest by title.
+      admin_sets_list.sort do |a, b|
+        if Hyrax::AdminSetCreateService.default_admin_set?(id: a[1])
+          -1
+        elsif Hyrax::AdminSetCreateService.default_admin_set?(id: b[1])
+          1
+        else
+          a[0] <=> b[0]
+        end
+      end
+    end
 
     ##
     # @return [Array<String>] the list of all user groups
@@ -233,7 +261,10 @@ module Hyrax
     # @return [ActiveSupport::SafeBuffer] license links, html_safe
     def license_links(options)
       service = Hyrax.config.license_service_class.new
-      to_sentence(options[:value].map { |right| link_to service.label(right), right })
+      to_sentence(options[:value].map do |right|
+        label = service.label(right) { right }
+        Hyrax::AuthorityRenderingHelper.linkable_uri?(right) ? link_to(label, right) : ERB::Util.h(label)
+      end)
     end
 
     # A Blacklight index field helper_method
@@ -241,7 +272,10 @@ module Hyrax
     # @return [ActiveSupport::SafeBuffer] rights statement links, html_safe
     def rights_statement_links(options)
       service = Hyrax.config.rights_statement_service_class.new
-      to_sentence(options[:value].map { |right| link_to service.label(right), right })
+      to_sentence(options[:value].map do |right|
+        label = service.label(right) { right }
+        Hyrax::AuthorityRenderingHelper.linkable_uri?(right) ? link_to(label, right) : ERB::Util.h(label)
+      end)
     end
 
     # A Blacklight facet field helper_method
@@ -288,6 +322,21 @@ module Hyrax
       tag.span("", class: [Hyrax::ModelIcon.css_class_for(::Collection), "collection-icon-search"])
     end
 
+    # Returns alt text for a thumbnail image.
+    # When the document has a custom thumbnail (thumbnail_alt_text indexed), delegates to
+    # alt_text_for_view to get the specific alt text. Otherwise returns a generic fallback
+    # (hyrax.sr.thumbnail) indicating a default representative image is shown.
+    # Apps can override this method to inject content-block lookups or other custom logic.
+    #
+    # @param document [SolrDocument]
+    # @param block_name [String] unused here; provided for API compatibility with overrides
+    # @return [String]
+    def thumbnail_alt_text_for(document, block_name: nil) # rubocop:disable Lint/UnusedMethodArgument
+      return document.alt_text_for_view if document.respond_to?(:thumbnail_alt_text) && document.thumbnail_alt_text.present?
+
+      t('hyrax.sr.thumbnail')
+    end
+
     def collection_title_by_id(id)
       solr_docs = controller.blacklight_config.repository.find(id).docs
       return nil if solr_docs.empty?

data/app/helpers/hyrax/iiif_helper.rb

@@ -10,8 +10,18 @@ module Hyrax
       'hyrax/base/iiif_viewers/' + work_presenter.iiif_viewer.to_s
     end
 
+    # For backwards compatibility
     def universal_viewer_base_url
-      "#{request&.base_url}/uv/uv.html"
+      iiif_viewer_base_url(:universal_viewer)
+    end
+
+    def iiif_viewer_base_url(viewer)
+      case viewer
+      when :universal_viewer
+        "#{request&.base_url}/uv/uv.html"
+      else
+        "#{request&.base_url}/#{viewer}/#{viewer}.html"
+      end
     end
 
     def universal_viewer_config_url

data/app/helpers/hyrax/permalink_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Hyrax
+  # Helpers for the "Copy permalink" button on work and collection show pages.
+  # See documentation/copy_permalink.md.
+  module PermalinkHelper
+    # The UUID-based URL for the record represented by `presenter`, so
+    # it is stable across alias changes and is safe to share or cite.
+    def permalink_for(presenter)
+      strip_query_string(request.base_url + Hyrax::PermalinkPath.call(presenter))
+    end
+
+    # The URL used in the show page's `<link rel="canonical">` tag.
+    def canonical_url_for(presenter)
+      display_path = Hyrax.config.redirects_active? && Hyrax::RedirectsLookup.display_path_for(presenter.id.to_s)
+      return permalink_for(presenter) if display_path.blank?
+      strip_query_string(request.base_url + display_path)
+    end
+
+    def copy_permalink_enabled?
+      Flipflop.enabled?(:copy_permalink_button)
+    end
+
+    private
+
+    # Removes the `?…` query string from a URL so the permalink is a clean
+    # canonical reference. Rails URL helpers append `?locale=...` (and any
+    # other registered `default_url_options`) by default; for a stable
+    # citable URL we want the bare host + path.
+    def strip_query_string(url)
+      parsed = URI.parse(url)
+      parsed.query = nil
+      parsed.fragment = nil
+      parsed.to_s
+    end
+  end
+end

data/app/helpers/hyrax/redirects_tab_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Decides whether the Aliases tab should appear on a work or
+  # collection edit form. Included into `WorkFormHelper` and
+  # `CollectionsHelper` so both forms share one rule.
+  #
+  # The tab appears only when the redirects feature is fully active
+  # (`Hyrax.config.redirects_active?`), the form is a ResourceForm
+  # (the only form pipeline with the redirects populator, validator,
+  # and prepopulator wired in), AND the form's underlying resource
+  # carries the `redirects` attribute. The structural check guards
+  # against adopter work or collection classes that don't include
+  # the redirects schema; without it the tab would render and crash
+  # on `f.object.redirects`.
+  module RedirectsTabHelper
+    def redirects_tab?(form)
+      return false unless Hyrax.config.redirects_active?
+      return false unless redirects_supported_form?(form)
+      target = form.respond_to?(:model) ? form.model : form
+      target.respond_to?(:redirects)
+    end
+
+    def redirects_supported_form?(form)
+      form.is_a?(Hyrax::Forms::ResourceForm)
+    end
+  end
+end

data/app/helpers/hyrax/work_form_helper.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 module Hyrax
   module WorkFormHelper
+    include Hyrax::RedirectsTabHelper
+
     ##
     # @todo this implementation hits database backends (solr) and is invoked
     #   from views. refactor to avoid
@@ -30,11 +32,13 @@ module Hyrax
     # @param form [Hyrax::Forms::WorkForm, Hyrax::Forms::ResourceForm]
     # @return [Array<String>] the list of names of tabs to be rendered in the form
     def form_tabs_for(form:)
-      if form.instance_of? Hyrax::Forms::BatchUploadForm
-        %w[files metadata relationships]
-      else
-        %w[metadata files relationships]
-      end
+      tabs = if form.instance_of? Hyrax::Forms::BatchUploadForm
+               %w[files metadata relationships]
+             else
+               %w[metadata files relationships]
+             end
+      tabs << 'redirects' if redirects_tab?(form)
+      tabs
     end
 
     ##

data/app/helpers/hyrax/works_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module WorksHelper
+    def available_collections(work:)
+      return [] if @current_ability.blank?
+
+      all_collections = Hyrax::CollectionsService.new(self).all_search_results(:deposit)
+      return all_collections if work.blank?
+
+      all_collections.reject { |col| work.member_of_collection_ids.include?(col.id) }
+    end
+  end
+end

data/app/indexers/concerns/hyrax/workflow_indexer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module WorkflowIndexer
+    # Write the workflow roles and state into the solr_document
+    # @param [Hash] solr_document the solr document to add the fields to
+    def to_solr
+      super.tap do |solr_doc|
+        index_workflow_fields(solr_doc)
+      end
+    end
+
+    # Write the workflow roles and state so one can see where the document moves to next
+    # @param [Hash] solr_document the solr document to add the field to
+    def index_workflow_fields(solr_document)
+      entity = Sipity::Entity(resource)
+      solr_document['actionable_workflow_roles_ssim'] = workflow_roles(entity).map { |role| "#{entity.workflow.permission_template.source_id}-#{entity.workflow.name}-#{role}" }
+      solr_document['workflow_state_name_ssim'] = entity.workflow_state.name if entity.workflow_state
+    rescue Sipity::ConversionError
+      nil
+    end
+
+    # Get the workflow roles for the entity
+    # @param [Sipity::Entity] entity the entity to get the workflow roles for
+    # @return [Array<String>] the workflow roles for the entity
+    def workflow_roles(entity)
+      Hyrax::Workflow::PermissionQuery.scope_roles_associated_with_the_given_entity(entity: entity)
+    end
+  end
+end

data/app/indexers/hyrax/file_set_indexer.rb

@@ -9,6 +9,7 @@ module Hyrax
       super.tap do |solr_doc|
         solr_doc['hasRelatedMediaFragment_ssim'] = object.representative_id
         solr_doc['hasRelatedImage_ssim'] = object.thumbnail_id
+        solr_doc['transcript_ids_ssim'] = object.transcript_ids
         # Label is the actual file name. It's not editable by the user.
         solr_doc['label_tesim'] = object.label
         solr_doc['label_ssi']   = object.label

data/app/indexers/hyrax/indexers/administrative_set_indexer.rb

@@ -7,7 +7,8 @@ module Hyrax
     class AdministrativeSetIndexer < Hyrax::Indexers::ResourceIndexer
       include Hyrax::PermissionIndexer
       include Hyrax::VisibilityIndexer
-      include Hyrax::Indexer(:core_metadata)
+      include Hyrax::Indexer(:core_metadata) if Hyrax.config.admin_set_include_metadata
+      check_if_flexible(Hyrax::AdministrativeSet)
 
       def to_solr # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         super.tap do |solr_doc|

data/app/indexers/hyrax/indexers/file_set_indexer.rb

@@ -8,8 +8,11 @@ module Hyrax
       include Hyrax::PermissionIndexer
       include Hyrax::VisibilityIndexer
       include Hyrax::ThumbnailIndexer
-      include Hyrax::Indexer(:core_metadata)
-      include Hyrax::Indexer(:file_set_metadata)
+      if Hyrax.config.file_set_include_metadata
+        include Hyrax::Indexer(:core_metadata)
+        include Hyrax::Indexer(:file_set_metadata)
+      end
+      check_if_flexible(Hyrax::FileSet)
 
       def to_solr # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         super.tap do |solr_doc| # rubocop:disable Metrics/BlockLength
@@ -21,6 +24,7 @@ module Hyrax
           solr_doc['extracted_text_id_ssi']        = resource.extracted_text_id.to_s
           solr_doc['hasRelatedMediaFragment_ssim'] = resource.representative_id.to_s
           solr_doc['hasRelatedImage_ssim']         = resource.thumbnail_id.to_s
+          solr_doc['transcript_ids_ssim']          = resource.transcript_ids&.map(&:to_s) if resource.respond_to?(:transcript_ids)
 
           index_lease(solr_doc)
           index_embargo(solr_doc)