🎁 WIP Flexible metadata for Valkyrie Objects

.dassie/.env

@@ -18,6 +18,7 @@ HYRAX_ANALYTICS=false
 HYRAX_ANALYTICS_PROVIDER=google
 HYRAX_DERIVATIVES_PATH=/app/samvera/hyrax-webapp/derivatives/
 HYRAX_ENGINE_PATH=/app/samvera/hyrax-engine
+HYRAX_FLEXIBLE=true
 HYRAX_UPLOAD_PATH=/app/samvera/hyrax-webapp/uploads/
 HYRAX_VALKYRIE=true
 IN_DOCKER=true

.dassie/app/models/collection_resource.rb

@@ -30,8 +30,8 @@ class CollectionResource < Hyrax::PcdmCollection
   # * add Valkyrie attributes to this class
   # * update form and indexer to process the attributes
   #
-  include Hyrax::Schema(:basic_metadata)
-  include Hyrax::Schema(:collection_resource)
+  include Hyrax::Schema(:basic_metadata) unless ENV.fetch('HYRAX_FLEXIBLE', false)
+  include Hyrax::Schema(:collection_resource) unless ENV.fetch('HYRAX_FLEXIBLE', false)
 
   Hyrax::ValkyrieLazyMigration.migrating(self, from: ::Collection)
 end

.dassie/app/models/generic_work_resource.rb

@@ -3,8 +3,8 @@
 # Generated via
 #  `rails generate hyrax:work_resource GenericWorkResource`
 class GenericWorkResource < Hyrax::Work
-  include Hyrax::Schema(:basic_metadata)
-  include Hyrax::Schema(:generic_work_resource)
+  include Hyrax::Schema(:basic_metadata) unless ENV.fetch('HYRAX_FLEXIBLE', false)
+  include Hyrax::Schema(:generic_work_resource) unless ENV.fetch('HYRAX_FLEXIBLE', false)
 
   Hyrax::ValkyrieLazyMigration.migrating(self, from: GenericWork)
 end

.dassie/app/models/monograph.rb

@@ -3,6 +3,6 @@
 # Generated via
 #  `rails generate hyrax:work_resource Monograph`
 class Monograph < Hyrax::Work
-  include Hyrax::Schema(:basic_metadata)
-  include Hyrax::Schema(:monograph)
+  include Hyrax::Schema(:basic_metadata) unless ENV.fetch('HYRAX_FLEXIBLE', false)
+  include Hyrax::Schema(:monograph) unless ENV.fetch('HYRAX_FLEXIBLE', false)
 end

.dassie/db/migrate/20240606205215_create_hyrax_flexible_schemas.rb

@@ -0,0 +1,10 @@
+class CreateHyraxFlexibleSchemas < ActiveRecord::Migration[6.1]
+  def change
+    create_table :hyrax_flexible_schemas do |t|
+      t.string :version, index: { unique: true }
+      t.text :profile
+
+      t.timestamps
+    end
+  end
+end

.dassie/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 2024_05_06_070809) do
+ActiveRecord::Schema.define(version: 2024_06_06_205215) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -172,6 +172,13 @@
     t.datetime "updated_at", null: false
   end
 
+  create_table "hyrax_flexible_schemas", force: :cascade do |t|
+    t.string "version"
+    t.text "profile"
+    t.datetime "created_at", precision: 6, null: false
+    t.datetime "updated_at", precision: 6, null: false
+  end
+
   create_table "job_io_wrappers", force: :cascade do |t|
     t.bigint "user_id"
     t.bigint "uploaded_file_id"

app/models/concerns/hyrax/flexibility.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module Flexibility
+    extend ActiveSupport::Concern
+    included do
+      attribute :schema_version,       Valkyrie::Types::String
+    end
+
+    class_methods do
+      ## Override dry-struct 1.6.0 to enable redefining schemas on the fly
+      def attributes(new_schema)
+        keys = new_schema.keys.map { |k| k.to_s.chomp("?").to_sym }
+        schema Hyrax::Resource.schema.schema(new_schema)
+
+        define_accessors(keys)
+
+        @attribute_names = nil
+
+        direct_descendants = descendants&.select { |d| d.superclass == self }
+        direct_descendants&.each do |d|
+          inherited_attrs = new_schema.reject { |k, _| d.has_attribute?(k.to_s.chomp("?").to_sym) }
+          d.attributes(inherited_attrs)
+        end
+
+        new_schema.each_key do |key|
+          key = key.to_s.chomp('?')
+          next if instance_methods.include?("#{key}=".to_sym)
+
+          class_eval(<<-RUBY)
+          def #{key}=(value)
+            set_value("#{key}".to_sym, value)
+          end
+        RUBY
+        end
+
+        self
+      end
+
+      ## Override dry-struct 1.6.0 to filter attributes after schema reload happens
+      def new(attributes = default_attributes, safe = false, &block) # rubocop:disable Style/OptionalBooleanParameter
+        if attributes.is_a?(Struct)
+          if equal?(attributes.class)
+            attributes
+          else
+            # This implicit coercion is arguable but makes sense overall
+            # in cases there you pass child struct to the base struct constructor
+            # User.new(super_user)
+            #
+            # We may deprecate this behavior in future forcing people to be explicit
+            new(attributes.to_h, safe, &block)
+          end
+        else
+          load(attributes, safe)
+        end
+      rescue Dry::Types::CoercionError => e
+        raise Dry::Error, "[#{self}.new] #{e}", e.backtrace
+      end
+
+      ## Read the schema from the database and load the correct schemas for the instance in to the class
+      def load(attributes, safe = false)
+        attributes[:schema_version] ||=  Hyrax::FlexibleSchema.order('created_at DESC').pick(:version)
+        struct = allocate
+        schema_version = attributes[:schema_version]
+        struct.singleton_class.attributes(Hyrax::Schema(self, schema_version:).attributes)
+        clean_attributes = safe ? struct.singleton_class.schema.call_safe(attributes) { |output = attributes| return yield output } : struct.singleton_class.schema.call_unsafe(attributes)
+        struct.__send__(:initialize, clean_attributes)
+        struct
+      end
+    end
+
+    # Override set_value from valkyrie 3.1.1 to enable dynamic schema loading
+    def set_value(key, value)
+      @attributes[key.to_sym] = self.singleton_class.schema.key(key.to_sym).type.call(value)
+    end
+
+    # Override inspect from dry-struct 1.6.0 to enable dynamic schema loading
+    def inspect
+      klass = self.singleton_class
+      attrs = klass.attribute_names.map { |key| " #{key}=#{@attributes[key].inspect}" }.join
+      "#<#{klass.name || klass.inspect}#{attrs}>"
+    end
+  end
+end

app/models/hyrax/administrative_set.rb

@@ -25,7 +25,7 @@ module Hyrax
   # @see Valkyrie query adapter's #find_inverse_references_by
   #
   class AdministrativeSet < Hyrax::Resource
-    include Hyrax::Schema(:core_metadata)
+    include Hyrax::Schema(:core_metadata) unless ENV.fetch('HYRAX_FLEXIBLE', false)
 
     attribute :alternative_title, Valkyrie::Types::Set.of(Valkyrie::Types::String)
     attribute :creator,           Valkyrie::Types::Set.of(Valkyrie::Types::String)

app/models/hyrax/file_set.rb

@@ -49,8 +49,8 @@ module Hyrax
   # @see Hyrax::CustomQueries::Navigators::ParentWorkNavigator#find_parent_work
   # @see https://wiki.duraspace.org/display/samvera/Hydra%3A%3AWorks+Shared+Modeling
   class FileSet < Hyrax::Resource
-    include Hyrax::Schema(:core_metadata)
-    include Hyrax::Schema(:file_set_metadata)
+    include Hyrax::Schema(:core_metadata) unless ENV.fetch('HYRAX_FLEXIBLE', false)
+    include Hyrax::Schema(:file_set_metadata)  unless ENV.fetch('HYRAX_FLEXIBLE', false)
 
     def self.model_name(name_class: Hyrax::Name)
       @_model_name ||= name_class.new(self, nil, 'FileSet')

app/models/hyrax/flexible_schema.rb

@@ -0,0 +1,40 @@
+class Hyrax::FlexibleSchema < ApplicationRecord
+  serialize :profile, coder: YAML
+
+  def attributes_for(class_name)
+    class_names[class_name]
+  end
+
+  def class_names
+    return @class_names if @class_names
+    @class_names = {}
+    profile['classes'].keys.each do |class_name|
+      @class_names[class_name] = {}
+    end
+    profile['properties'].each do |key, values|
+      values['available_on']['class'].each do |property_class|
+        # map some m3 items to what Hyrax expects
+        values = values_map(values)
+        @class_names[property_class][key] = values
+      end
+    end
+    @class_names
+  end
+
+  def values_map(values)
+    values['type'] = lookup_type(value['range'])
+    values['predicate'] = value['property_uri']
+    values['index_keys'] = values['indexing']
+    values['multiple'] = values['multi_value']
+    values
+  end
+
+  def lookup_type(range)
+    case range
+    when "http://www.w3.org/2001/XMLSchema#dateTime"
+      'date_time'
+    else
+      range.split('#').last.underscore
+    end
+  end
+end

app/models/hyrax/pcdm_collection.rb

@@ -40,7 +40,7 @@ module Hyrax
   # @see Hyrax::CustomQueries::Navigators::CollectionMembers#find_members_of
   #
   class PcdmCollection < Hyrax::Resource
-    include Hyrax::Schema(:core_metadata)
+    include Hyrax::Schema(:core_metadata) unless ENV.fetch('HYRAX_FLEXIBLE', false)
 
     attribute :collection_type_gid, Valkyrie::Types::String
     attribute :member_ids, Valkyrie::Types::Array.of(Valkyrie::Types::ID).meta(ordered: true)

app/models/hyrax/resource.rb

@@ -31,6 +31,7 @@ module Hyrax
   #   implementations).
   #
   class Resource < Valkyrie::Resource
+    include Hyrax::Flexibility if ENV.fetch('HYRAX_FLEXIBLE', false)
     include Hyrax::Naming
     include Hyrax::WithEvents
 

app/models/hyrax/work.rb

@@ -94,7 +94,7 @@ module Hyrax
   # @see https://wiki.lyrasis.org/display/samvera/Hydra::Works+Shared+Modeling
   #   for a historical perspective.
   class Work < Hyrax::Resource
-    include Hyrax::Schema(:core_metadata)
+    include  Hyrax::Schema(:core_metadata) unless ENV.fetch('HYRAX_FLEXIBLE', false)
 
     attribute :admin_set_id,             Valkyrie::Types::ID
     attribute :member_ids,               Valkyrie::Types::Array.of(Valkyrie::Types::ID).meta(ordered: true)

app/services/hyrax/m3_schema_loader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # @api private
+  #
+  # Read m3 profiles from the database
+  #
+  # @see config/metadata/m3_profile.yaml for an example configuration
+  class M3SchemaLoader < Hyrax::SchemaLoader
+    private
+
+    ##
+    # @param [#to_s] schema_name
+    # @return [Enumerable<AttributeDefinition]
+    def definitions(schema_name, version)
+      Hyrax::FlexibleSchema.find_by(version: version).attributes_for(schema_name).map do |name, config|
+        AttributeDefinition.new(name, config)
+      end
+    end
+  end
+end

app/services/hyrax/schema_loader.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # @api private
+  #
+  # This is a simple yaml config-driven schema loader
+  #
+  # @see config/metadata/basic_metadata.yaml for an example configuration
+  class SchemaLoader
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash<Symbol, Dry::Types::Type>] a map from attribute names to
+    #   types
+    def attributes_for(schema:, version: 1)
+      definitions(schema).each_with_object({}) do |definition, hash|
+        hash[definition.name] = definition.type.meta(definition.config)
+      end
+    end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash{Symbol => Hash{Symbol => Object}}]
+    def form_definitions_for(schema:, version: 1)
+      definitions(schema).each_with_object({}) do |definition, hash|
+        next if definition.form_options.empty?
+
+        hash[definition.name] = definition.form_options
+      end
+    end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [{Symbol => Symbol}] a map from index keys to attribute names
+    def index_rules_for(schema:, version: 1)
+      definitions(schema).each_with_object({}) do |definition, hash|
+        definition.index_keys.each do |key|
+          hash[key] = definition.name
+        end
+      end
+    end
+
+    ##
+    # @api private
+    class AttributeDefinition
+      ##
+      # @!attr_reader :config
+      #   @return [Hash<String, Object>]
+      # @!attr_reader :name
+      #   @return [#to_sym]
+      attr_reader :config, :name
+
+      ##
+      # @param [#to_sym] name
+      # @param [Hash<String, Object>] config
+      def initialize(name, config)
+        @config = config
+        @name   = name.to_sym
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}]
+      def form_options
+        config.fetch('form', {}).symbolize_keys
+      end
+
+      ##
+      # @return [Enumerable<Symbol>]
+      def index_keys
+        config.fetch('index_keys', []).map(&:to_sym)
+      end
+
+      ##
+      # @return [Dry::Types::Type]
+      def type
+        collection_type = if config['multiple']
+                            Valkyrie::Types::Array.constructor { |v| Array(v).select(&:present?) }
+                          else
+                            Identity
+                          end
+        collection_type.of(type_for(config['type']))
+      end
+
+      ##
+      # @api private
+      #
+      # This class acts as a Valkyrie/Dry::Types collection with typed members,
+      # but instead of wrapping the given type with itself as the collection type
+      # (as in `Valkyrie::Types::Array.of(MyType)`), it returns the given type.
+      #
+      # @example
+      #   Identity.of(Valkyrie::Types::String) # => Valkyrie::Types::String
+      #
+      class Identity
+        ##
+        # @param [Dry::Types::Type]
+        # @return [Dry::Types::Type] the type passed in
+        def self.of(type)
+          type
+        end
+      end
+
+      private
+
+      ##
+      # Maps a configuration string value to a `Valkyrie::Type`.
+      #
+      # @param [String]
+      # @return [Dry::Types::Type]
+      def type_for(type)
+        case type
+        when 'id'
+          Valkyrie::Types::ID
+        when 'uri'
+          Valkyrie::Types::URI
+        when 'date_time'
+          Valkyrie::Types::DateTime
+        else
+          "Valkyrie::Types::#{type.capitalize}".constantize
+        end
+      end
+    end
+
+    class UndefinedSchemaError < ArgumentError; end
+
+  end
+end