valkyrie 2.0.1 → 2.2.0

data/lib/valkyrie/persistence/postgres/orm_converter.rb

@@ -21,65 +21,65 @@ module Valkyrie::Persistence::Postgres
 
     private
 
-      # Construct a new Valkyrie Resource using the attributes retrieved from the database
-      # @return [Valkyrie::Resource]
-      def resource
-        resource_klass.new(
-          attributes.merge(
-            new_record: false,
-            Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token
-          )
+    # Construct a new Valkyrie Resource using the attributes retrieved from the database
+    # @return [Valkyrie::Resource]
+    def resource
+      resource_klass.new(
+        attributes.merge(
+          new_record: false,
+          Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token
         )
-      end
+      )
+    end
 
-      # Construct the optimistic lock token using the adapter and lock version for the Resource
-      # @return [Valkyrie::Persistence::OptimisticLockToken]
-      def lock_token
-        return lock_token_warning unless orm_object.class.column_names.include?("lock_version")
-        @lock_token ||=
-          Valkyrie::Persistence::OptimisticLockToken.new(
-            adapter_id: resource_factory.adapter_id,
-            token: orm_object.lock_version
-          )
-      end
+    # Construct the optimistic lock token using the adapter and lock version for the Resource
+    # @return [Valkyrie::Persistence::OptimisticLockToken]
+    def lock_token
+      return lock_token_warning unless orm_object.class.column_names.include?("lock_version")
+      @lock_token ||=
+        Valkyrie::Persistence::OptimisticLockToken.new(
+          adapter_id: resource_factory.adapter_id,
+          token: orm_object.lock_version
+        )
+    end
 
-      # Issue a migration warning for previous releases of Valkyrie which did not support optimistic locking
-      def lock_token_warning
-        return nil unless resource_klass.optimistic_locking_enabled?
-        warn "[MIGRATION REQUIRED] You have loaded a resource from the Postgres adapter with " \
-             "optimistic locking enabled, but the necessary migrations have not been run. \n" \
-             "Please run `bin/rails valkyrie_engine:install:migrations && bin/rails db:migrate` " \
-             "to enable this feature for Postgres."
-        nil
-      end
+    # Issue a migration warning for previous releases of Valkyrie which did not support optimistic locking
+    def lock_token_warning
+      return nil unless resource_klass.optimistic_locking_enabled?
+      warn "[MIGRATION REQUIRED] You have loaded a resource from the Postgres adapter with " \
+           "optimistic locking enabled, but the necessary migrations have not been run. \n" \
+           "Please run `bin/rails valkyrie_engine:install:migrations && bin/rails db:migrate` " \
+           "to enable this feature for Postgres."
+      nil
+    end
 
-      # Retrieve the Class used to construct the Valkyrie Resource
-      # @return [Class]
-      def resource_klass
-        Valkyrie.config.resource_class_resolver.call(internal_resource)
-      end
+    # Retrieve the Class used to construct the Valkyrie Resource
+    # @return [Class]
+    def resource_klass
+      Valkyrie.config.resource_class_resolver.call(internal_resource)
+    end
 
-      # Access the String for the Valkyrie Resource type within the attributes
-      # @return [String]
-      def internal_resource
-        attributes[:internal_resource]
-      end
+    # Access the String for the Valkyrie Resource type within the attributes
+    # @return [String]
+    def internal_resource
+      attributes[:internal_resource]
+    end
 
-      # @return [Hash] Valkyrie-style hash of attributes.
-      def attributes
-        @attributes ||= orm_object.attributes.merge(rdf_metadata).symbolize_keys
-      end
+    # @return [Hash] Valkyrie-style hash of attributes.
+    def attributes
+      @attributes ||= orm_object.attributes.merge(rdf_metadata).symbolize_keys
+    end
 
-      # Generate a Hash derived from Valkyrie Resource metadata encoded in the RDF
-      # @return [Hash]
-      def rdf_metadata
-        @rdf_metadata ||= RDFMetadata.new(orm_object.metadata).result
-      end
+    # Generate a Hash derived from Valkyrie Resource metadata encoded in the RDF
+    # @return [Hash]
+    def rdf_metadata
+      @rdf_metadata ||= RDFMetadata.new(orm_object.metadata).result
+    end
 
-      # Responsible for converting `metadata` JSON-B field in
-      # {Valkyrie::Persistence::Postgres::ORM::Resource} into an acceptable hash
-      # for {Valkyrie::Resource}
-      class RDFMetadata < ::Valkyrie::Persistence::Shared::JSONValueMapper
-      end
+    # Responsible for converting `metadata` JSON-B field in
+    # {Valkyrie::Persistence::Postgres::ORM::Resource} into an acceptable hash
+    # for {Valkyrie::Resource}
+    class RDFMetadata < ::Valkyrie::Persistence::Shared::JSONValueMapper
+    end
   end
 end

data/lib/valkyrie/persistence/postgres/query_service.rb

@@ -35,6 +35,13 @@ module Valkyrie::Persistence::Postgres
       end
     end
 
+    # Count all records for a specific resource type
+    # @param [Class] model
+    # @return integer
+    def count_all_of_model(model:)
+      orm_class.where(internal_resource: model.to_s).count
+    end
+
     # Find a record using a Valkyrie ID, and map it to a Valkyrie Resource
     # @param [Valkyrie::ID, String] id
     # @return [Valkyrie::Resource]
@@ -94,30 +101,28 @@ module Valkyrie::Persistence::Postgres
       find_inverse_references_by(resource: resource, property: :member_ids)
     end
 
-    # Find all resources related to a given Valkyrie Resource by a property
-    # @param [Valkyrie::Resource] resource
-    # @param [String] property
-    # @return [Array<Valkyrie::Resource>]
-    def find_references_by(resource:, property:)
+    # (see Valkyrie::Persistence::Memory::QueryService#find_references_by)
+    def find_references_by(resource:, property:, model: nil)
       return [] if resource.id.blank? || resource[property].blank?
       # only return ordered if needed to avoid performance penalties
       if ordered_property?(resource: resource, property: property)
-        run_query(find_ordered_references_query, property, resource.id.to_s)
+        find_ordered_references_by(resource: resource, property: property, model: model)
       else
-        run_query(find_references_query, property, resource.id.to_s)
+        find_unordered_references_by(resource: resource, property: property, model: model)
       end
     end
 
-    # Find all resources referencing a given Valkyrie Resource by a property
-    # @param [Valkyrie::Resource] resource
-    # @param [String] property
-    # @return [Array<Valkyrie::Resource>]
-    def find_inverse_references_by(resource: nil, id: nil, property:)
+    # (see Valkyrie::Persistence::Memory::QueryService#find_inverse_references_by)
+    def find_inverse_references_by(resource: nil, id: nil, property:, model: nil)
       raise ArgumentError, "Provide resource or id" unless resource || id
       ensure_persisted(resource) if resource
       id ||= resource.id
       internal_array = "{\"#{property}\": [{\"id\": \"#{id}\"}]}"
-      run_query(find_inverse_references_query, internal_array)
+      if model
+        run_query(find_inverse_references_with_type_query, internal_array, model)
+      else
+        run_query(find_inverse_references_query, internal_array)
+      end
     end
 
     # Execute a query in SQL for resource records and map them to Valkyrie
@@ -180,6 +185,21 @@ module Valkyrie::Persistence::Postgres
       SQL
     end
 
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   JSON object literal (e. g. { "alternate_ids": [{"id": "d6e88f80-41b3-4dbf-a2a0-cd79e20f6d10"}] }).
+    #   and resource type as arguments
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # This uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
+    def find_inverse_references_with_type_query
+      <<-SQL
+        SELECT * FROM orm_resources WHERE
+        metadata @> ?
+        AND internal_resource = ?
+      SQL
+    end
+
     # Generate the SQL query for retrieving member resources in PostgreSQL using a
     #   JSON object literal and resource ID as arguments.
     # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
@@ -197,6 +217,14 @@ module Valkyrie::Persistence::Postgres
       SQL
     end
 
+    def find_references_with_type_query
+      <<-SQL
+        SELECT DISTINCT member.* FROM orm_resources a,
+        jsonb_array_elements(a.metadata->?) AS b(member)
+        JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ? AND member.internal_resource = ?
+      SQL
+    end
+
     def find_ordered_references_query
       <<-SQL
         SELECT member.* FROM orm_resources a,
@@ -206,6 +234,15 @@ module Valkyrie::Persistence::Postgres
       SQL
     end
 
+    def find_ordered_references_with_type_query
+      <<-SQL
+        SELECT member.* FROM orm_resources a,
+        jsonb_array_elements(a.metadata->?) WITH ORDINALITY AS b(member, member_pos)
+        JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ? AND member.internal_resource = ?
+        ORDER BY b.member_pos
+      SQL
+    end
+
     # Constructs a Valkyrie::Persistence::CustomQueryContainer using this query service
     # @return [Valkyrie::Persistence::CustomQueryContainer]
     def custom_queries
@@ -214,30 +251,46 @@ module Valkyrie::Persistence::Postgres
 
     private
 
-      # Determines whether or not an Object is a Valkyrie ID
-      # @param [Object] id
-      # @raise [ArgumentError]
-      def validate_id(id)
-        raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
+    def find_ordered_references_by(resource:, property:, model: nil)
+      if model
+        run_query(find_ordered_references_with_type_query, property, resource.id.to_s, model)
+      else
+        run_query(find_ordered_references_query, property, resource.id.to_s)
       end
+    end
 
-      # Determines whether or not a resource has been persisted
-      # @param [Object] resource
-      # @raise [ArgumentError]
-      def ensure_persisted(resource)
-        raise ArgumentError, 'resource is not saved' unless resource.persisted?
+    def find_unordered_references_by(resource:, property:, model: nil)
+      if model
+        run_query(find_references_with_type_query, property, resource.id.to_s, model)
+      else
+        run_query(find_references_query, property, resource.id.to_s)
       end
+    end
 
-      # Accesses the data type in PostgreSQL used for the primary key
-      # (For example, a UUID)
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaCache.html#method-i-columns_hash
-      # @return [Symbol]
-      def id_type
-        @id_type ||= orm_class.columns_hash["id"].type
-      end
+    # Determines whether or not an Object is a Valkyrie ID
+    # @param [Object] id
+    # @raise [ArgumentError]
+    def validate_id(id)
+      raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
+    end
 
-      def ordered_property?(resource:, property:)
-        resource.ordered_attribute?(property)
-      end
+    # Determines whether or not a resource has been persisted
+    # @param [Object] resource
+    # @raise [ArgumentError]
+    def ensure_persisted(resource)
+      raise ArgumentError, 'resource is not saved' unless resource.persisted?
+    end
+
+    # Accesses the data type in PostgreSQL used for the primary key
+    # (For example, a UUID)
+    # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaCache.html#method-i-columns_hash
+    # @return [Symbol]
+    def id_type
+      @id_type ||= orm_class.columns_hash["id"].type
+    end
+
+    def ordered_property?(resource:, property:)
+      resource.ordered_attribute?(property)
+    end
   end
 end

data/lib/valkyrie/persistence/postgres/resource_converter.rb

@@ -20,7 +20,7 @@ module Valkyrie::Persistence::Postgres
         orm_object.internal_resource = resource.internal_resource
         process_lock_token(orm_object)
         orm_object.disable_optimistic_locking! unless resource.optimistic_locking_enabled?
-        orm_object.metadata.merge!(attributes)
+        orm_object.metadata = attributes
       end
     end
 

data/lib/valkyrie/persistence/shared/json_value_mapper.rb

@@ -152,7 +152,7 @@ module Valkyrie::Persistence::Shared
       # Generates a Time object in the UTC from the datestamp string value
       # @return [Time]
       def result
-        DateTime.iso8601(value).utc
+        DateTime.iso8601(value).new_offset(0)
       end
     end
   end

data/lib/valkyrie/persistence/solr/model_converter.rb

@@ -65,412 +65,412 @@ module Valkyrie::Persistence::Solr
 
     private
 
-      # Maps Solr Document fields to attributes with single values
-      # Filters for fields which store the Valkyrie resource type
-      # @param [Hash] attribute_hash
-      # @return [Hash]
-      def add_single_values(attribute_hash)
-        attribute_hash.select do |k, v|
-          field = k.to_s.split("_").last
-          property = k.to_s.gsub("_#{field}", "")
-          next true if multivalued?(field)
-          next false if property == "internal_resource"
-          next false if v.length > 1
-          true
-        end
+    # Maps Solr Document fields to attributes with single values
+    # Filters for fields which store the Valkyrie resource type
+    # @param [Hash] attribute_hash
+    # @return [Hash]
+    def add_single_values(attribute_hash)
+      attribute_hash.select do |k, v|
+        field = k.to_s.split("_").last
+        property = k.to_s.gsub("_#{field}", "")
+        next true if multivalued?(field)
+        next false if property == "internal_resource"
+        next false if v.length > 1
+        true
       end
+    end
 
-      # Determines whether or not a field is multivalued
-      # @note this is tied to conventions in the Solr Schema
-      # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
-      # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
-      # @param [String] field
-      # @return [Boolean]
-      def multivalued?(field)
-        field.end_with?('m', 'mv')
-      end
+    # Determines whether or not a field is multivalued
+    # @note this is tied to conventions in the Solr Schema
+    # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
+    # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
+    # @param [String] field
+    # @return [Boolean]
+    def multivalued?(field)
+      field.end_with?('m', 'mv')
+    end
 
-      # If optimistic locking is enabled for this Valkyrie Resource, generates a Hash containing the locking token
-      # @return [Hash]
-      def lock_hash
-        return {} unless resource.optimistic_locking_enabled? && lock_token.present?
-        { _version_: lock_token }
-      end
+    # If optimistic locking is enabled for this Valkyrie Resource, generates a Hash containing the locking token
+    # @return [Hash]
+    def lock_hash
+      return {} unless resource.optimistic_locking_enabled? && lock_token.present?
+      { _version_: lock_token }
+    end
 
-      # Retrieves the lock token from the resource attributes
-      # @return [String]
-      def lock_token
-        @lock_token ||= begin
-          found_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
-                        .find { |token| token.adapter_id == resource_factory.adapter_id }
-          return if found_token.nil?
-          found_token.token
-        end
+    # Retrieves the lock token from the resource attributes
+    # @return [String]
+    def lock_token
+      @lock_token ||= begin
+        found_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+                      .find { |token| token.adapter_id == resource_factory.adapter_id }
+        return if found_token.nil?
+        found_token.token
       end
+    end
 
-      # Generates the Valkyrie Resource attribute Hash
-      # @return [Hash]
-      def attribute_hash
-        properties.each_with_object({}) do |property, hsh|
-          next if property == Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK
-          attr = resource_attributes[property]
-          mapper_val = SolrMapperValue.for(Property.new(property, attr)).result
-          unless mapper_val.respond_to?(:apply_to)
-            raise "Unable to cast #{resource_attributes[:internal_resource]}#" \
-                  "#{property} which has been set to an instance of '#{attr.class}'"
-          end
-          mapper_val.apply_to(hsh)
-        end
+    # Generates the Valkyrie Resource attribute Hash
+    # @return [Hash]
+    def attribute_hash
+      properties.each_with_object({}) do |property, hsh|
+        next if property == Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK
+        attr = resource_attributes[property]
+        mapper_val = SolrMapperValue.for(Property.new(property, attr)).result
+        unless mapper_val.respond_to?(:apply_to)
+          raise "Unable to cast #{resource_attributes[:internal_resource]}#" \
+                "#{property} which has been set to an instance of '#{attr.class}'"
+        end
+        mapper_val.apply_to(hsh)
       end
+    end
 
-      # Accesses the keys for the attributes on the Valkyrie Resource
-      # @return [Array<Symbol>]
-      def properties
-        resource_attributes.keys - [:id, :created_at, :updated_at, :new_record]
-      end
-
-      # Access the attributes for the Valkyrie resources
-      # @return [Hash]
-      def resource_attributes
-        @resource_attributes ||= resource.attributes
-      end
-
-      ##
-      # A container resource for holding a `key`, `value, and `scope` of a value
-      # in a resource together for casting.
-      class Property
-        attr_reader :key, :value, :scope
-        # @param key [Symbol] Property identifier.
-        # @param value [Object] Value or list of values which are underneath the
-        #   key.
-        # @param scope [Object] The resource or point where the key and values
-        #   came from.
-        def initialize(key, value, scope = [])
-          @key = key
-          @value = value
-          @scope = scope
-        end
+    # Accesses the keys for the attributes on the Valkyrie Resource
+    # @return [Array<Symbol>]
+    def properties
+      resource_attributes.keys - [:id, :created_at, :updated_at, :new_record]
+    end
+
+    # Access the attributes for the Valkyrie resources
+    # @return [Hash]
+    def resource_attributes
+      @resource_attributes ||= resource.attributes
+    end
+
+    ##
+    # A container resource for holding a `key`, `value, and `scope` of a value
+    # in a resource together for casting.
+    class Property
+      attr_reader :key, :value, :scope
+      # @param key [Symbol] Property identifier.
+      # @param value [Object] Value or list of values which are underneath the
+      #   key.
+      # @param scope [Object] The resource or point where the key and values
+      #   came from.
+      def initialize(key, value, scope = [])
+        @key = key
+        @value = value
+        @scope = scope
       end
+    end
 
-      ##
-      # Represents a key/value combination in the solr document, used for isolating logic around
-      # how to apply a value to a hash.
-      class SolrRow
-        attr_reader :key, :fields, :values
-        # @param key [Symbol] Solr key.
-        # @param fields [Array<Symbol>] Field suffixes to index into.
-        # @param values [Array] Values to index into the given fields.
-        def initialize(key:, fields:, values:)
-          @key = key
-          @fields = Array.wrap(fields)
-          @values = Array.wrap(values)
-        end
+    ##
+    # Represents a key/value combination in the solr document, used for isolating logic around
+    # how to apply a value to a hash.
+    class SolrRow
+      attr_reader :key, :fields, :values
+      # @param key [Symbol] Solr key.
+      # @param fields [Array<Symbol>] Field suffixes to index into.
+      # @param values [Array] Values to index into the given fields.
+      def initialize(key:, fields:, values:)
+        @key = key
+        @fields = Array.wrap(fields)
+        @values = Array.wrap(values)
+      end
 
-        # @param hsh [Hash] The solr hash to apply to.
-        # @return [Hash] The updated solr hash.
-        def apply_to(hsh)
-          return hsh if values.blank?
-          fields.each do |field|
-            hsh["#{key}_#{field}".to_sym] ||= []
-            hsh["#{key}_#{field}".to_sym] += values
-          end
-          hsh
+      # @param hsh [Hash] The solr hash to apply to.
+      # @return [Hash] The updated solr hash.
+      def apply_to(hsh)
+        return hsh if values.blank?
+        fields.each do |field|
+          hsh["#{key}_#{field}".to_sym] ||= []
+          hsh["#{key}_#{field}".to_sym] += values
         end
+        hsh
       end
+    end
 
-      ##
-      # Wraps up multiple SolrRows to apply them all at once, while looking like
-      # just one.
-      class CompositeSolrRow
-        attr_reader :solr_rows
+    ##
+    # Wraps up multiple SolrRows to apply them all at once, while looking like
+    # just one.
+    class CompositeSolrRow
+      attr_reader :solr_rows
 
-        # @param [Array<Valkyrie::Persistence::Solr::Mapper::SolrRow>] solr_rows
-        def initialize(solr_rows)
-          @solr_rows = solr_rows
-        end
+      # @param [Array<Valkyrie::Persistence::Solr::Mapper::SolrRow>] solr_rows
+      def initialize(solr_rows)
+        @solr_rows = solr_rows
+      end
 
-        # Merge a Hash of attribute values into a logical row of Solr fields
-        # @param [Hash] hsh
-        # @see Valkyrie::Persistence::Solr::Mapper::SolrRow#apply_to
-        def apply_to(hsh)
-          solr_rows.each do |solr_row|
-            solr_row.apply_to(hsh)
-          end
-          hsh
+      # Merge a Hash of attribute values into a logical row of Solr fields
+      # @param [Hash] hsh
+      # @see Valkyrie::Persistence::Solr::Mapper::SolrRow#apply_to
+      def apply_to(hsh)
+        solr_rows.each do |solr_row|
+          solr_row.apply_to(hsh)
         end
+        hsh
       end
+    end
 
-      # Container for casting mappers.
-      class SolrMapperValue < ::Valkyrie::ValueMapper
-      end
+    # Container for casting mappers.
+    class SolrMapperValue < ::Valkyrie::ValueMapper
+    end
 
-      # Casts {Boolean} values into a recognizable string in Solr.
-      class BooleanPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Casts {Boolean} values into a recognizable string in Solr.
+    class BooleanPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value behaves like a boolean value
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && ([true, false].include? value.value)
-        end
+      # Determines whether or not a Property value behaves like a boolean value
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && ([true, false].include? value.value)
+      end
 
-        # Constructs a SolrRow object for a Property with a Boolean value
-        # @note this prepends the string "boolean-" to the value indexed in Solr
-        # @return [SolrRow]
-        def result
-          calling_mapper.for(Property.new(value.key, "boolean-#{value.value}")).result
-        end
+      # Constructs a SolrRow object for a Property with a Boolean value
+      # @note this prepends the string "boolean-" to the value indexed in Solr
+      # @return [SolrRow]
+      def result
+        calling_mapper.for(Property.new(value.key, "boolean-#{value.value}")).result
       end
+    end
 
-      # Casts nested resources into a JSON string in solr.
-      class NestedObjectValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Casts nested resources into a JSON string in solr.
+    class NestedObjectValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is a Hash
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.value.is_a?(Hash) || value.value.is_a?(Valkyrie::Resource)
-        end
+      # Determines whether or not a Property value is a Hash
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.value.is_a?(Hash) || value.value.is_a?(Valkyrie::Resource)
+      end
 
-        # Constructs a SolrRow object for a Property with a Hash value
-        # @note this prepends the string "serialized-" to the value indexed in Solr
-        # This is indexed as a stored multivalued text
-        # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
-        # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
-        # @return [SolrRow]
-        def result
-          SolrRow.new(key: value.key, fields: ["tsim"], values: "serialized-#{value.value.to_json}")
-        end
+      # Constructs a SolrRow object for a Property with a Hash value
+      # @note this prepends the string "serialized-" to the value indexed in Solr
+      # This is indexed as a stored multivalued text
+      # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
+      # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
+      # @return [SolrRow]
+      def result
+        SolrRow.new(key: value.key, fields: ["tsim"], values: "serialized-#{value.value.to_json}")
       end
+    end
 
-      # Casts enumerable values one by one.
-      class EnumerableValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Casts enumerable values one by one.
+    class EnumerableValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is an Array
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.is_a?(Array)
-        end
+      # Determines whether or not a Property value is an Array
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.is_a?(Array)
+      end
 
-        # Constructs a CompositeSolrRow object for a set of Property values
-        # @return [CompositeSolrRow]
-        def result
-          CompositeSolrRow.new(
-            value.value.map do |val|
-              calling_mapper.for(Property.new(value.key, val, value.value)).result
-            end
-          )
-        end
+      # Constructs a CompositeSolrRow object for a set of Property values
+      # @return [CompositeSolrRow]
+      def result
+        CompositeSolrRow.new(
+          value.value.map do |val|
+            calling_mapper.for(Property.new(value.key, val, value.value)).result
+          end
+        )
       end
+    end
 
-      # Skips nil values.
-      class NilPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Skips nil values.
+    class NilPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value responds as nil
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.nil?
-        end
+      # Determines whether or not a Property value responds as nil
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.nil?
+      end
 
-        # Constructs a SolrRow object for a Property with a nil value
-        # @return [SolrRow]
-        def result
-          SolrRow.new(key: value.key, fields: [], values: nil)
-        end
+      # Constructs a SolrRow object for a Property with a nil value
+      # @return [SolrRow]
+      def result
+        SolrRow.new(key: value.key, fields: [], values: nil)
       end
+    end
 
-      # Casts {Valkyrie::ID} values into a recognizable string in solr.
-      class IDPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Casts {Valkyrie::ID} values into a recognizable string in solr.
+    class IDPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is a Valkyrie ID
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.is_a?(::Valkyrie::ID)
-        end
+      # Determines whether or not a Property value is a Valkyrie ID
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.is_a?(::Valkyrie::ID)
+      end
 
-        # Constructs a SolrRow object for the Property Valkyrie ID value
-        # @note this prepends the string "id-" to the value indexed in Solr
-        # @return [SolrRow]
-        def result
-          calling_mapper.for(Property.new(value.key, "id-#{value.value.id}")).result
-        end
+      # Constructs a SolrRow object for the Property Valkyrie ID value
+      # @note this prepends the string "id-" to the value indexed in Solr
+      # @return [SolrRow]
+      def result
+        calling_mapper.for(Property.new(value.key, "id-#{value.value.id}")).result
       end
+    end
 
-      # Casts {RDF::URI} values into a recognizable string in solr.
-      class URIPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Casts {RDF::URI} values into a recognizable string in solr.
+    class URIPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is a URI
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.is_a?(::RDF::URI)
-        end
+      # Determines whether or not a Property value is a URI
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.is_a?(::RDF::URI)
+      end
 
-        # Constructs a SolrRow object for the Property URI value
-        # @note this prepends the string "uri-" to the value indexed in Solr
-        # @return [SolrRow]
-        def result
-          calling_mapper.for(Property.new(value.key, "uri-#{value.value}")).result
-        end
+      # Constructs a SolrRow object for the Property URI value
+      # @note this prepends the string "uri-" to the value indexed in Solr
+      # @return [SolrRow]
+      def result
+        calling_mapper.for(Property.new(value.key, "uri-#{value.value}")).result
       end
+    end
 
-      # Casts {Integer} values into a recognizable string in Solr.
-      class IntegerPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Casts {Integer} values into a recognizable string in Solr.
+    class IntegerPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is an Integer
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.is_a?(Integer)
-        end
+      # Determines whether or not a Property value is an Integer
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.is_a?(Integer)
+      end
 
-        # Constructs a SolrRow object for the Property Integer value
-        # @note this prepends the string "integer-" to the value indexed in Solr
-        # @return [SolrRow]
-        def result
-          calling_mapper.for(Property.new(value.key, "integer-#{value.value}")).result
-        end
+      # Constructs a SolrRow object for the Property Integer value
+      # @note this prepends the string "integer-" to the value indexed in Solr
+      # @return [SolrRow]
+      def result
+        calling_mapper.for(Property.new(value.key, "integer-#{value.value}")).result
       end
+    end
 
-      # Casts {Float} values into a recognizable string in Solr.
-      class FloatPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.is_a?(Float)
-        end
+    # Casts {Float} values into a recognizable string in Solr.
+    class FloatPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.is_a?(Float)
+      end
 
-        def result
-          calling_mapper.for(Property.new(value.key, "float-#{value.value}")).result
-        end
+      def result
+        calling_mapper.for(Property.new(value.key, "float-#{value.value}")).result
       end
+    end
 
-      # Casts {DateTime} values into a recognizable string in Solr.
-      class DateTimePropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Casts {DateTime} values into a recognizable string in Solr.
+    class DateTimePropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is a DateTime or Time
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && (value.value.is_a?(Time) || value.value.is_a?(DateTime))
-        end
+      # Determines whether or not a Property value is a DateTime or Time
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && (value.value.is_a?(Time) || value.value.is_a?(DateTime))
+      end
 
-        # Constructs a SolrRow object for a datestamp derived from the value
-        # @note this prepends the string "datetime-" to the value indexed in Solr
-        # @return [SolrRow]
-        def result
-          calling_mapper.for(Property.new(value.key, "datetime-#{JSON.parse(to_datetime(value.value).to_json)}")).result
-        end
+      # Constructs a SolrRow object for a datestamp derived from the value
+      # @note this prepends the string "datetime-" to the value indexed in Solr
+      # @return [SolrRow]
+      def result
+        calling_mapper.for(Property.new(value.key, "datetime-#{JSON.parse(to_datetime(value.value).to_json)}")).result
+      end
 
-        private
+      private
 
-          # Converts a value to a UTC timestamp if it is a DateTime or behaves like a Time value
-          # @param [Object] value
-          # @return [Time]
-          def to_datetime(value)
-            return value.utc if value.is_a?(DateTime)
-            return value.to_datetime.utc if value.respond_to?(:to_datetime)
-          end
+      # Converts a value to a UTC timestamp if it is a DateTime or behaves like a Time value
+      # @param [Object] value
+      # @return [Time]
+      def to_datetime(value)
+        return value.new_offset(0) if value.is_a?(DateTime)
+        return value.to_datetime.new_offset(0) if value.respond_to?(:to_datetime)
       end
+    end
 
-      # Handles casting language-tagged strings when there are both
-      # language-tagged and non-language-tagged strings in Solr. Assumes English
-      # for non-language-tagged strings.
-      class SharedStringPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Handles casting language-tagged strings when there are both
+    # language-tagged and non-language-tagged strings in Solr. Assumes English
+    # for non-language-tagged strings.
+    class SharedStringPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is a String whether or not the Property has an RDF literal specifying the language tag
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.is_a?(String) && value.scope.find { |x| x.is_a?(::RDF::Literal) }.present?
-        end
+      # Determines whether or not a Property value is a String whether or not the Property has an RDF literal specifying the language tag
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.is_a?(String) && value.scope.find { |x| x.is_a?(::RDF::Literal) }.present?
+      end
 
-        # Constructs a CompositeSolrRow object with the language-tagged literal value
-        # @return [CompositeSolrRow]
-        def result
-          CompositeSolrRow.new(
-            [
-              calling_mapper.for(Property.new(value.key, value.value)).result,
-              calling_mapper.for(Property.new("#{value.key}_lang", "eng")).result,
-              calling_mapper.for(Property.new("#{value.key}_type", "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")).result
-            ]
-          )
-        end
+      # Constructs a CompositeSolrRow object with the language-tagged literal value
+      # @return [CompositeSolrRow]
+      def result
+        CompositeSolrRow.new(
+          [
+            calling_mapper.for(Property.new(value.key, value.value)).result,
+            calling_mapper.for(Property.new("#{value.key}_lang", "eng")).result,
+            calling_mapper.for(Property.new("#{value.key}_type", "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")).result
+          ]
+        )
       end
+    end
 
-      # Handles casting strings.
-      class StringPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Handles casting strings.
+    class StringPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is a String
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.is_a?(String)
-        end
+      # Determines whether or not a Property value is a String
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.is_a?(String)
+      end
 
-        # Constructs a SolrRow object with the String values and Solr field settings
-        # @return [SolrRow]
-        def result
-          SolrRow.new(key: value.key, fields: fields, values: value.value)
-        end
+      # Constructs a SolrRow object with the String values and Solr field settings
+      # @return [SolrRow]
+      def result
+        SolrRow.new(key: value.key, fields: fields, values: value.value)
+      end
 
-        # Generates the Solr fields used during the indexing
-        # String are normally indexed using the following:
-        #   - stored text
-        #   - stored english text
-        #   - stored single string
-        #   - multivalued string
-        #   - stored multivalued text
-        #   - stored multivalued english text
-        # If the string is greater than 1000 characters in length, it is only indexed as a stored multivalued text
-        # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
-        # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
-        # @return [Array<Symbol>]
-        def fields
-          if value.value.length > 1000
-            [:tsim]
-          else
-            [:tsim, :ssim, :tesim, :tsi, :ssi, :tesi]
-          end
+      # Generates the Solr fields used during the indexing
+      # String are normally indexed using the following:
+      #   - stored text
+      #   - stored english text
+      #   - stored single string
+      #   - multivalued string
+      #   - stored multivalued text
+      #   - stored multivalued english text
+      # If the string is greater than 1000 characters in length, it is only indexed as a stored multivalued text
+      # @see https://lucene.apache.org/solr/guide/defining-fields.html#defining-fields
+      # @see https://github.com/samvera-labs/valkyrie/blob/master/solr/config/schema.xml
+      # @return [Array<Symbol>]
+      def fields
+        if value.value.length > 1000
+          [:tsim]
+        else
+          [:tsim, :ssim, :tesim, :tsi, :ssi, :tesi]
         end
       end
+    end
 
-      # Handles casting language-typed {RDF::Literal}s
-      class LiteralPropertyValue < ::Valkyrie::ValueMapper
-        SolrMapperValue.register(self)
+    # Handles casting language-typed {RDF::Literal}s
+    class LiteralPropertyValue < ::Valkyrie::ValueMapper
+      SolrMapperValue.register(self)
 
-        # Determines whether or not a Property value is an RDF literal
-        # @param [Object] value
-        # @return [Boolean]
-        def self.handles?(value)
-          value.is_a?(Property) && value.value.is_a?(::RDF::Literal)
-        end
+      # Determines whether or not a Property value is an RDF literal
+      # @param [Object] value
+      # @return [Boolean]
+      def self.handles?(value)
+        value.is_a?(Property) && value.value.is_a?(::RDF::Literal)
+      end
 
-        # Constructs a CompositeSolrRow object with the language-tagged literal value
-        # @return [CompositeSolrRow]
-        def result
-          key = value.key
-          val = value.value
-          CompositeSolrRow.new(
-            [
-              calling_mapper.for(Property.new(key, val.to_s)).result,
-              calling_mapper.for(Property.new("#{key}_lang", val.language.to_s)).result,
-              calling_mapper.for(Property.new("#{key}_type", val.datatype.to_s)).result
-            ]
-          )
-        end
+      # Constructs a CompositeSolrRow object with the language-tagged literal value
+      # @return [CompositeSolrRow]
+      def result
+        key = value.key
+        val = value.value
+        CompositeSolrRow.new(
+          [
+            calling_mapper.for(Property.new(key, val.to_s)).result,
+            calling_mapper.for(Property.new("#{key}_lang", val.language.to_s)).result,
+            calling_mapper.for(Property.new("#{key}_type", val.datatype.to_s)).result
+          ]
+        )
       end
+    end
   end
 end