hyrax 5.2.0 → 5.3.0

data/app/services/hyrax/flexible_schema_validators/class_validator.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module FlexibleSchemaValidators
+    # Handles class-related validations for flexible metadata profiles
+    class ClassValidator
+      # @param profile [Hash] M3 profile data
+      # @param required_classes [Array<String>] Foundational classes that must be present
+      # @param errors [Array<String>] Array to append validation errors to
+      def initialize(profile, required_classes, errors)
+        @profile = profile
+        @required_classes = required_classes
+        @errors = errors
+      end
+
+      # Validates that referenced classes are registered Hyrax curation concern
+      # types and that Valkyrie models use the correct `...Resource` naming
+      # convention when applicable.
+      #
+      # @return [void]
+      def validate_availability!
+        classes_to_validate = all_profile_classes - @required_classes
+        invalid_classes = []
+        mismatched_valkyrie_classes = []
+
+        classes_to_validate.each do |klass|
+          validate_class(klass, invalid_classes, mismatched_valkyrie_classes)
+        end
+
+        report_mismatched_classes(mismatched_valkyrie_classes)
+        report_invalid_classes(invalid_classes)
+      end
+
+      # Validates that all classes referenced within property `available_on`
+      # definitions are themselves defined in the top-level `classes` section of
+      # the profile.
+      #
+      # @return [void]
+      def validate_references!
+        properties = @profile['properties'] || {}
+
+        referenced_classes = properties.values.flat_map do |prop|
+          prop.dig('available_on', 'class')
+        end.compact.uniq
+
+        undefined_classes = referenced_classes - @profile['classes'].keys
+
+        return if undefined_classes.empty?
+
+        @errors << "Classes referenced in `available_on` but not defined in `classes`: #{undefined_classes.join(', ')}."
+      end
+
+      private
+
+      # Gathers all unique class names from both the top-level `classes`
+      # definition and all `available_on` property references.
+      #
+      # @return [Array<String>]
+      def all_profile_classes
+        profile_classes = @profile.fetch('classes', {}).keys
+        properties = @profile['properties'] || {}
+        available_on_classes = properties.values.flat_map do |prop|
+          prop.dig('available_on', 'class')
+        end.compact
+
+        clean_class_names(profile_classes + available_on_classes).uniq
+      end
+
+      def clean_class_names(names)
+        names.map { |name| name.to_s.strip.gsub(/^::/, '') }
+      end
+
+      # Validates a single class, checking for registration as a curation concern
+      # and for Valkyrie naming mismatches using the Valkyrie resolver.
+      #
+      # @param klass [String] the class name to validate
+      # @param invalid_classes [Array<String>] an array to append invalid class errors to
+      # @param mismatched_valkyrie_classes [Array<Hash>] an array to append Valkyrie mismatch errors to
+      # @return [void]
+      def validate_class(klass, invalid_classes, mismatched_valkyrie_classes)
+        base_class_name = klass.gsub(/(?<=.)Resource$/, '')
+        unless Hyrax.config.registered_curation_concern_types.include?(base_class_name)
+          invalid_classes << klass
+          return
+        end
+
+        begin
+          expected_valkyrie_class = Valkyrie.config.resource_class_resolver.call(base_class_name)
+          expected_class_name = expected_valkyrie_class.to_s
+
+          mismatched_valkyrie_classes << { non_resource: klass, resource: expected_class_name } if klass != expected_class_name
+        rescue NameError
+          # This occurs if a registered concern doesn't have a loadable backing class,
+          # which is an invalid state.
+          invalid_classes << klass
+        end
+      end
+
+      # Appends a formatted error message for any Valkyrie naming mismatches.
+      #
+      # @param mismatched_classes [Array<Hash>]
+      # @return [void]
+      def report_mismatched_classes(mismatched_classes)
+        return if mismatched_classes.empty?
+
+        message = mismatched_classes.map do |mismatch|
+          "'#{mismatch[:non_resource]}' should be '#{mismatch[:resource]}'"
+        end.join(', ')
+        @errors << "Mismatched Valkyrie classes found: #{message}."
+      end
+
+      # Appends a formatted error message for any invalid classes.
+      #
+      # @param invalid_classes [Array<String>]
+      # @return [void]
+      def report_invalid_classes(invalid_classes)
+        return if invalid_classes.empty?
+
+        @errors << "Invalid classes: #{invalid_classes.join(', ')}."
+      end
+    end
+  end
+end

data/app/services/hyrax/flexible_schema_validators/core_metadata_validator.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module FlexibleSchemaValidators
+    ##
+    # @api private
+    #
+    # Validates the core metadata properties of a flexible metadata profile.
+    class CoreMetadataValidator
+      ##
+      # @param profile [Hash] the flexible metadata profile
+      # @param errors [Array<String>] an array to append errors to
+      def initialize(profile:, errors:)
+        @profile = profile
+        @errors = errors
+      end
+
+      # Validate the profile against the core metadata requirements and append
+      # any human-readable error messages to {#errors}.
+      #
+      # @return [void]
+      def validate!
+        core_metadata['attributes'].each do |property, config|
+          next unless validate_property_exists(property)
+
+          validate_property_multi_value(property, config)
+          validate_property_indexing(property, config)
+          validate_property_predicate(property, config)
+          validate_property_available_on(property)
+          validate_property_cardinality(property, config)
+        end
+        validate_keyword_property
+      end
+
+      private
+
+      attr_reader :profile, :errors
+
+      # Load and memoize the core metadata definition from
+      # `config/metadata/core_metadata.yaml`.
+      #
+      # @return [Hash] the core metadata configuration with indifferent access
+      def core_metadata
+        return @core_metadata if @core_metadata
+
+        @core_metadata = YAML.safe_load(
+          File.read(Hyrax::Engine.root.join('config', 'metadata', 'core_metadata.yaml'))
+        ).with_indifferent_access
+
+        # Ensure the `creator` attribute is always treated as core metadata even
+        # when it is not present in the YAML definition shipped with Hyrax.
+        @core_metadata['attributes'] ||= {}
+
+        @core_metadata['attributes']['creator'] ||= {
+          'type' => 'string',
+          'multiple' => true,
+          'index_keys' => ['creator_sim', 'creator_tesim'],
+          'predicate' => 'http://purl.org/dc/elements/1.1/creator'
+        }
+
+        @core_metadata
+      end
+
+      # Memoized convenience accessor that returns the class keys defined in
+      # the profile.
+      #
+      # @return [Array<String>]
+      def defined_classes
+        @defined_classes ||= profile['classes'].keys
+      end
+
+      # Ensures the given property is present in the profile's `properties`
+      # section.
+      #
+      # @param property [String, Symbol] the property name
+      # @return [Boolean] true if the property exists, otherwise false
+      def validate_property_exists(property)
+        return true if profile['properties'][property].present?
+
+        errors << "Missing required property: #{property}."
+        false
+      end
+
+      # Validate that the property's `data_type` matches the expected type
+      # based on the core metadata's `multiple` setting.
+      #
+      # @param property [String, Symbol] the property name
+      # @param config [Hash] the core metadata configuration for the property
+      # @return [void]
+      def validate_property_multi_value(property, config)
+        return unless config.key?("multiple")
+
+        property_config = profile.dig('properties', property) || {}
+
+        required_data_type = config['multiple'] ? 'array' : 'string'
+
+        actual_data_type = determine_data_type_from_config(property_config)
+
+        return if actual_data_type == required_data_type
+
+        errors << "Property '#{property}' must have data_type set to '#{required_data_type}'."
+      end
+
+      # Determine the property's effective data type from its configuration.
+      #
+      # @param property_config [Hash] the property's configuration from the profile
+      # @return [String] either 'array' or 'string'
+      def determine_data_type_from_config(property_config)
+        if property_config['data_type']
+          property_config['data_type']
+        elsif property_config['multi_value']
+          'array'
+        else
+          'string'
+        end
+      end
+
+      # Validate that the profile includes all indexing keys required by the
+      # core metadata configuration.
+      #
+      # @param property [String, Symbol]
+      # @param config [Hash]
+      # @return [void]
+      def validate_property_indexing(property, config)
+        return unless config.key?('index_keys')
+
+        profile_indexing = profile.dig('properties', property, 'indexing') || []
+        missing_keys = config['index_keys'] - profile_indexing
+
+        return if missing_keys.empty?
+
+        errors << "Property '#{property}' is missing required indexing: #{missing_keys.join(', ')}."
+      end
+
+      # Ensures that the property's predicate matches the core metadata definition.
+      #
+      # @param property [String, Symbol]
+      # @param config [Hash]
+      # @return [void]
+      def validate_property_predicate(property, config)
+        return unless config.key?('predicate')
+        return if profile.dig('properties', property, 'property_uri') == config['predicate']
+
+        errors << "Property '#{property}' must have property_uri set to #{config['predicate']}."
+      end
+
+      # Validates that if the `keyword` property is present, it is correctly
+      # configured as a multi-valued field.
+      #
+      # @return [void]
+      def validate_keyword_property
+        keyword_prop = profile.dig('properties', 'keyword')
+        return unless keyword_prop
+
+        return if keyword_prop['data_type'] == 'array'
+
+        errors << "Property 'keyword' must have data_type set to 'array'."
+      end
+
+      # Checks that the property is available on all classes defined in the profile.
+      # A property entry with `name: <property>` is treated as an alias and counts
+      # toward coverage for the resolved name.
+      #
+      # @param property [String, Symbol]
+      # @return [void]
+      def validate_property_available_on(property)
+        available_on_classes = classes_covered_by_resolved_name(property.to_s)
+        missing_classes = defined_classes - available_on_classes
+
+        return if missing_classes.empty?
+        errors << "Property '#{property}' must be available on all classes, but is missing from: #{missing_classes.join(', ')}."
+      end
+
+      # Returns all classes covered by any profile property whose resolved name
+      # matches +property_name+ (either directly or via the `name` override key).
+      #
+      # @param property_name [String]
+      # @return [Array<String>]
+      def classes_covered_by_resolved_name(property_name)
+        profile['properties'].each_with_object([]) do |(key, config), covered|
+          resolved = (config['name'] || key).to_s
+          next unless resolved == property_name
+
+          covered.concat(Array(config.dig('available_on', 'class')))
+        end
+      end
+
+      # Validates the property's cardinality, ensuring that `title` is required
+      # (i.e., has a minimum cardinality of 1).
+      #
+      # @param property [String, Symbol]
+      # @param _config [Hash] the core metadata configuration for the property (unused)
+      # @return [void]
+      def validate_property_cardinality(property, _config)
+        # Ensure that the `title` property is always required by enforcing
+        # a cardinality minimum of at least 1.  According to the M3 profile
+        # specification, `cardinality.minimum` > 0 is interpreted as
+        # "required".
+        return unless property.to_s == 'title'
+
+        minimum = profile.dig('properties', property, 'cardinality', 'minimum')
+
+        # Treat missing `cardinality` or `minimum` as 0 (i.e., not required).
+        required = minimum.to_i.positive?
+        return if required
+
+        errors << "Property 'title' must have a cardinality minimum of at least 1."
+      end
+    end
+  end
+end

data/app/services/hyrax/flexible_schema_validators/existing_records_validator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module FlexibleSchemaValidators
+    # Validates that classes with existing records in the repository are not removed from the profile.
+    class ExistingRecordsValidator
+      # @param profile [Hash] M3 profile data
+      # @param required_classes [Array<String>] Foundational classes that must be present
+      # @param errors [Array<String>] Array to append validation errors to
+      def initialize(profile, required_classes, errors)
+        @profile = profile
+        @required_classes = required_classes
+        @errors = errors
+      end
+
+      # Validates that no classes with existing records in the repository have been
+      # removed from the profile.
+      #
+      # @return [void]
+      def validate!
+        profile_classes_set = Set.new(@profile.fetch('classes', {}).keys)
+        classes_with_records = []
+        potential_existing_classes.each do |model_class|
+          model_identifier = model_class.to_s
+          counterpart_identifier = counterpart_for(model_identifier)
+
+          # If this model or its counterpart is in the profile, we don't need to check it for removal.
+          next if profile_classes_set.include?(model_identifier) || profile_classes_set.include?(counterpart_identifier)
+
+          # If it's not in the profile, check if it has records.
+          classes_with_records << model_identifier if model_has_records?(model_class, model_identifier)
+        end
+
+        return if classes_with_records.empty?
+
+        @errors << "Classes with existing records cannot be removed from the profile: #{classes_with_records.uniq.join(', ')}."
+      end
+
+      private
+
+      # Determines the counterpart model name (e.g., Image -> ImageResource).
+      def counterpart_for(model_identifier)
+        return unless defined?(Wings)
+
+        klass = model_identifier.safe_constantize
+        return if klass.blank?
+
+        Wings::ModelRegistry.lookup(klass).to_s
+      rescue NameError
+        # This can happen if a class is not loadable,
+        # or if a counterpart model does not exist.
+        nil
+      end
+
+      # Queries the repository to see if a given model has any records.
+      def model_has_records?(model_class, class_name)
+        Hyrax.query_service.count_all_of_model(model: model_class).positive?
+      rescue StandardError => e
+        Rails.logger.error "Error checking records for #{class_name}: #{e.message}"
+        false
+      end
+
+      # Gathers all unique, canonical model classes that could potentially have records.
+      # @return [Array<Class>]
+      def potential_existing_classes
+        return @models if @models.present?
+        @models = @required_classes.clone.map(&:safe_constantize)
+        Hyrax.config.registered_curation_concern_types.each do |concern_type|
+          resource = concern_type.match?(/Resource$/) ? concern_type : "#{concern_type}Resource"
+          resource.safe_constantize
+          @models << Valkyrie.config.resource_class_resolver.call(concern_type)
+        rescue NameError, LoadError
+          # This can happen if a concern is registered but its class is not loadable.
+          # We can safely ignore it, as it couldn't have records anyway.
+          Rails.logger.warn "Could not resolve model class for registered concern: #{concern_type}"
+        end
+
+        @models.uniq!
+        @models
+      end
+    end
+  end
+end

data/app/services/hyrax/flexible_schema_validators/redirects_validator.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module FlexibleSchemaValidators
+    ##
+    # @api private
+    #
+    # Validates the `redirects` property in an m3 profile against the
+    # two-layer feature gating (config + Flipflop):
+    #
+    # | config | flipflop | property | result                              |
+    # |--------|----------|----------|-------------------------------------|
+    # | off    | n/a      | present  | warn (property will be ignored)     |
+    # | off    | n/a      | absent   | silent                              |
+    # | on     | off      | present  | warn (property is loaded but unused)|
+    # | on     | off      | absent   | silent                              |
+    # | on     | on       | absent   | error (property is required)        |
+    # | on     | on       | present  | check available_on.class lists at   |
+    # |        |          |          | least one work or collection class  |
+    # |        |          |          | declared in this profile's classes  |
+    class RedirectsValidator
+      ##
+      # @param profile [Hash] the flexible metadata profile
+      # @param errors [Array<String>] an array to append errors to
+      # @param warnings [Array<String>] an array to append warnings to
+      def initialize(profile:, errors:, warnings: [])
+        @profile = profile
+        @errors = errors
+        @warnings = warnings
+      end
+
+      # Validate the profile against the redirects requirements and append
+      # any human-readable error messages to {#errors} (or warnings to
+      # {#warnings} for the dead-property cases).
+      #
+      # @return [void]
+      def validate!
+        return validate_when_config_off unless Hyrax.config.redirects_enabled?
+        return validate_when_flipflop_off unless Flipflop.redirects?
+
+        validate_when_enabled
+      end
+
+      private
+
+      def redirects_property
+        @redirects_property ||= @profile&.dig('properties', 'redirects')
+      end
+
+      def validate_when_config_off
+        return if redirects_property.blank?
+        @warnings << I18n.t('hyrax.flexible_schema_validators.redirects_validator.warnings.config_disabled')
+      end
+
+      def validate_when_flipflop_off
+        return if redirects_property.blank?
+        @warnings << I18n.t('hyrax.flexible_schema_validators.redirects_validator.warnings.flipflop_disabled')
+      end
+
+      def validate_when_enabled
+        if redirects_property.blank?
+          @errors << I18n.t('hyrax.flexible_schema_validators.redirects_validator.errors.property_required')
+          return
+        end
+
+        @errors << I18n.t('hyrax.flexible_schema_validators.redirects_validator.errors.invalid_type', actual_type: redirects_property['type'].inspect) unless redirects_property['type'].to_s == 'hash'
+
+        available_on = clean(Array(redirects_property.dig('available_on', 'class')))
+        return if (available_on & profile_work_or_collection_classes).any?
+
+        @errors << I18n.t('hyrax.flexible_schema_validators.redirects_validator.errors.invalid_available_on')
+      end
+
+      # Class names declared in this m3 profile's top-level `classes:` block,
+      # filtered to keep only those that represent works or collections.
+      # FileSets, AdminSets, and any non-work/non-collection class are
+      # excluded — redirects only apply to works and collections.
+      def profile_work_or_collection_classes
+        @profile_work_or_collection_classes ||= begin
+          declared = clean(Array(@profile&.dig('classes')&.keys))
+          declared.select { |name| work_or_collection?(name) }
+        end
+      end
+
+      def work_or_collection?(class_name)
+        registered_collection_names.include?(class_name) ||
+          registered_work_names.include?(class_name)
+      end
+
+      def registered_collection_names
+        @registered_collection_names ||= clean(Hyrax::ModelRegistry.collection_class_names)
+      end
+
+      # Work class names from the registry, with collection / file_set /
+      # admin_set names explicitly excluded. The registry can include any
+      # class an adopter has registered as a curation concern, so the
+      # exclusion guards against e.g. a FileSet being registered alongside
+      # works and slipping through as a "work" type for redirects.
+      # Each registered name is also paired with its `Resource`-suffixed
+      # Valkyrie equivalent — `class_validator` accepts both forms.
+      def registered_work_names
+        @registered_work_names ||= begin
+          works = clean(Hyrax::ModelRegistry.work_class_names)
+          works -= clean(Hyrax::ModelRegistry.collection_class_names)
+          works -= clean(Hyrax::ModelRegistry.file_set_class_names)
+          works -= clean(Hyrax::ModelRegistry.admin_set_class_names)
+          works.flat_map { |name| [name, "#{name}Resource"] }
+        end
+      end
+
+      def clean(names)
+        names.map { |name| name.to_s.delete_prefix('::') }
+      end
+    end
+  end
+end

data/app/services/hyrax/flexible_schema_validators/schema_validator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module FlexibleSchemaValidators
+    # Handles JSON schema validation for flexible metadata profiles
+    class SchemaValidator
+      def initialize(schemer, profile, errors)
+        @schemer = schemer
+        @profile = profile
+        @errors = errors
+      end
+
+      def validate!
+        @schemer.validate(@profile).to_a&.each do |error|
+          pointer = error['data_pointer']
+          type = error['type']
+
+          if pointer.end_with?('/available_on') && error['data'].nil? && type == 'object'
+            @errors << "Schema error at `#{pointer}`: `available_on` cannot be empty and must have a `class` or `context` sub-property."
+          elsif type == 'required'
+            missing_keys = error.dig('details', 'missing_keys')&.join("', '")
+            @errors << "Schema error at `#{pointer}`: Missing required properties: '#{missing_keys}'."
+          else
+            @errors << "Schema error at `#{pointer}`: Invalid value `#{error['data'].inspect}` for type `#{type}`."
+          end
+        end
+      end
+
+      private
+
+      attr_reader :schemer, :profile, :errors
+    end
+  end
+end

data/app/services/hyrax/flexible_schema_validators/sort_properties_validator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module FlexibleSchemaValidators
+    class SortPropertiesValidator
+      attr_reader :profile, :sort_properties
+
+      def initialize(profile, warnings)
+        @profile = profile
+        @warnings = warnings
+        @sort_properties = find_sort_properties
+      end
+
+      def validate!
+        sort_properties.each do |property|
+          properties_without_sort_properties = work_types_from_profile - (profile.dig('properties', property, 'available_on', 'class') || [])
+          next if properties_without_sort_properties.empty?
+
+          msg = I18n.t(
+            'hyrax.flexible_schema_validators.sort_properties_validator.warnings.message',
+            property: property,
+            classes: properties_without_sort_properties.join(', ')
+          )
+          @warnings << msg
+        end
+      end
+
+      private
+
+      def find_sort_properties
+        CatalogController.blacklight_config.sort_fields.keys.filter_map do |sort_key|
+          field = sort_key.split.first.sub(/_[^_]*$/, '')
+          field unless system_properties.include?(field)
+        end.uniq
+      end
+
+      def system_properties
+        %w[score system_modified system_create]
+      end
+
+      def work_types_from_profile
+        work_types = available_works.map do |work_type|
+          Valkyrie.config.resource_class_resolver.call(work_type).to_s
+        end
+
+        profile['classes'].keys.filter_map { |klass_name| klass_name if work_types.include?(klass_name) }
+      end
+
+      def available_works
+        Hyrax.config.registered_curation_concern_types
+      end
+    end
+  end
+end

data/app/services/hyrax/license_service.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Hyrax
   # Provide select options for the license (dcterms:rights) field
-  class LicenseService < QaSelectService
+  class LicenseService < TolerantSelectService
     def initialize(_authority_name = nil)
       super('licenses')
     end

data/app/services/hyrax/listeners/metadata_index_listener.rb

@@ -52,6 +52,8 @@ module Hyrax
 
       ##
       # Re-index the resource.
+      # If the updated object is a file set used as the thumbnail of a parent work,
+      # also reindex that parent so thumbnail_alt_text_tesim stays fresh.
       #
       # Called when 'object.metadata.updated' event is published
       # @param [Dry::Events::Event] event
@@ -59,6 +61,7 @@ module Hyrax
       def on_object_metadata_updated(event)
         return unless resource? event[:object]
         Hyrax.index_adapter.save(resource: event[:object])
+        reindex_parent_for_thumbnail(event[:object]) if event[:object].file_set?
       end
 
       ##
@@ -96,6 +99,14 @@ module Hyrax
 
       private
 
+      def reindex_parent_for_thumbnail(file_set)
+        parent = Hyrax.custom_queries.find_parent_work(resource: file_set)
+        return unless parent&.thumbnail_id == file_set.id
+        Hyrax.index_adapter.save(resource: parent)
+      rescue Valkyrie::Persistence::ObjectNotFoundError, Hyrax::ObjectNotFoundError
+        nil
+      end
+
       def resource?(resource)
         return true if resource.is_a? Valkyrie::Resource
         log_non_resource(resource)