valkyrie 0.1.0 → 1.0.0.rc1

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

@@ -2,6 +2,7 @@
 require 'valkyrie/persistence/postgres/orm'
 require 'valkyrie/persistence/postgres/resource_factory'
 module Valkyrie::Persistence::Postgres
+  # Persister for Postgres MetadataAdapter.
   class Persister
     attr_reader :adapter
     delegate :resource_factory, to: :adapter
@@ -11,6 +12,7 @@ module Valkyrie::Persistence::Postgres
 
     # (see Valkyrie::Persistence::Memory::Persister#save)
     def save(resource:)
+      ensure_multiple_values!(resource)
       orm_object = resource_factory.from_resource(resource: resource)
       orm_object.save!
       resource_factory.to_resource(object: orm_object)
@@ -29,5 +31,19 @@ module Valkyrie::Persistence::Postgres
       orm_object.delete
       resource
     end
+
+    # (see Valkyrie::Persistence::Memory::Persister#wipe!)
+    def wipe!
+      resource_factory.orm_class.delete_all
+    end
+
+    private
+
+      def ensure_multiple_values!(resource)
+        bad_keys = resource.attributes.except(:internal_resource, :created_at, :updated_at, :new_record, :id).select do |_k, v|
+          !v.nil? && !v.is_a?(Array)
+        end
+        raise ::Valkyrie::Persistence::UnsupportedDatatype, "#{resource}: #{bad_keys.keys} have non-array values, which can not be persisted by Valkyrie. Cast to arrays." unless bad_keys.keys.empty?
+      end
   end
 end

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

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
-require 'valkyrie/persistence/postgres/queries'
 module Valkyrie::Persistence::Postgres
+  # Query Service for the Postgres Metadata Adapter
+  #
+  # Most queries are delegated through to the ActiveRecord model
+  # {Valkyrie::Persistence::Postgres::ORM::Resource}
+  #
+  # @see Valkyrie::Persistence::Postgres::MetadataAdapter
   class QueryService
     attr_reader :adapter
     delegate :resource_factory, to: :adapter
@@ -25,14 +30,36 @@ module Valkyrie::Persistence::Postgres
 
     # (see Valkyrie::Persistence::Memory::QueryService#find_by)
     def find_by(id:)
-      resource_factory.to_resource(object: orm_class.find(id))
+      id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
+      validate_id(id)
+      resource_factory.to_resource(object: orm_class.find(id.to_s))
+    rescue ActiveRecord::RecordNotFound
+      raise Valkyrie::Persistence::ObjectNotFoundError
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_many_by_ids)
+    def find_many_by_ids(ids:)
+      ids.map! do |id|
+        id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
+        validate_id(id)
+        id.to_s
+      end
+
+      orm_class.where(id: ids).map do |orm_resource|
+        resource_factory.to_resource(object: orm_resource)
+      end
     rescue ActiveRecord::RecordNotFound
       raise Valkyrie::Persistence::ObjectNotFoundError
     end
 
     # (see Valkyrie::Persistence::Memory::QueryService#find_members)
-    def find_members(resource:)
-      Valkyrie::Persistence::Postgres::Queries::FindMembersQuery.new(resource, resource_factory: resource_factory).run
+    def find_members(resource:, model: nil)
+      return [] if resource.id.blank?
+      if model
+        run_query(find_members_with_type_query, resource.id.to_s, model.to_s)
+      else
+        run_query(find_members_query, resource.id.to_s)
+      end
     end
 
     # (see Valkyrie::Persistence::Memory::QueryService#find_parents)
@@ -42,12 +69,73 @@ module Valkyrie::Persistence::Postgres
 
     # (see Valkyrie::Persistence::Memory::QueryService#find_references_by)
     def find_references_by(resource:, property:)
-      Valkyrie::Persistence::Postgres::Queries::FindReferencesQuery.new(resource, property, resource_factory: resource_factory).run
+      return [] if resource.id.blank? || resource[property].blank?
+      run_query(find_references_query, property, resource.id.to_s)
     end
 
     # (see Valkyrie::Persistence::Memory::QueryService#find_inverse_references_by)
     def find_inverse_references_by(resource:, property:)
-      Valkyrie::Persistence::Postgres::Queries::FindInverseReferencesQuery.new(resource, property, resource_factory: resource_factory).run
+      ensure_persisted(resource)
+      internal_array = "{\"#{property}\": [{\"id\": \"#{resource.id}\"}]}"
+      run_query(find_inverse_references_query, internal_array)
+    end
+
+    def run_query(query, *args)
+      orm_class.find_by_sql(([query] + args)).lazy.map do |object|
+        resource_factory.to_resource(object: object)
+      end
+    end
+
+    def find_members_query
+      <<-SQL
+        SELECT member.* FROM orm_resources a,
+        jsonb_array_elements(a.metadata->'member_ids') WITH ORDINALITY AS b(member, member_pos)
+        JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
+        ORDER BY b.member_pos
+      SQL
+    end
+
+    def find_members_with_type_query
+      <<-SQL
+        SELECT member.* FROM orm_resources a,
+        jsonb_array_elements(a.metadata->'member_ids') 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
+
+    def find_inverse_references_query
+      <<-SQL
+        SELECT * FROM orm_resources WHERE
+        metadata @> ?
+      SQL
+    end
+
+    def find_references_query
+      <<-SQL
+        SELECT 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 = ?
+      SQL
+    end
+
+    def custom_queries
+      @custom_queries ||= ::Valkyrie::Persistence::CustomQueryContainer.new(query_service: self)
     end
+
+    private
+
+      def validate_id(id)
+        raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
+      end
+
+      def ensure_persisted(resource)
+        raise ArgumentError, 'resource is not saved' unless resource.persisted?
+      end
+
+      def id_type
+        @id_type ||= orm_class.columns_hash["id"].type
+      end
   end
 end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Postgres
+  # Responsible for converting a {Valkyrie::Resource} into a
+  # {Valkyrie::Persistence::Postgres::ORM::Resource}
   class ResourceConverter
     delegate :orm_class, to: :resource_factory
     attr_reader :resource, :resource_factory
@@ -9,7 +11,7 @@ module Valkyrie::Persistence::Postgres
     end
 
     def convert!
-      orm_class.find_or_initialize_by(id: resource.id.to_s).tap do |orm_object|
+      orm_class.find_or_initialize_by(id: resource.id && resource.id.to_s).tap do |orm_object|
         orm_object.internal_resource = resource.internal_resource
         orm_object.metadata.merge!(resource.attributes.except(:id, :internal_resource, :created_at, :updated_at))
       end

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

@@ -2,9 +2,11 @@
 require 'valkyrie/persistence/postgres/orm_converter'
 require 'valkyrie/persistence/postgres/resource_converter'
 module Valkyrie::Persistence::Postgres
+  # Provides access to generic methods for converting to/from
+  # {Valkyrie::Resource} and {Valkyrie::Persistence::Postgres::ORM::Resource}.
   class ResourceFactory
     class << self
-      # @param orm_object [Valkyrie::Persistence::Postgres::ORM::Resource] AR
+      # @param object [Valkyrie::Persistence::Postgres::ORM::Resource] AR
       #   record to be converted.
       # @return [Valkyrie::Resource] Model representation of the AR record.
       def to_resource(object:)
@@ -16,12 +18,10 @@ module Valkyrie::Persistence::Postgres
       #   resource for the Valkyrie resource.
       def from_resource(resource:)
         ::Valkyrie::Persistence::Postgres::ResourceConverter.new(resource, resource_factory: self).convert!
-        # ::Valkyrie::Persistence::Postgres::ORM::Resource.find_or_initialize_by(id: resource.id.to_s).tap do |orm_object|
-        #   orm_object.internal_resource = resource.internal_resource
-        #   orm_object.metadata.merge!(resource.attributes.except(:id, :internal_resource, :created_at, :updated_at))
-        # end
       end
 
+      # Accessor for the ActiveRecord class which all Postgres resources are an
+      # instance of.
       def orm_class
         ::Valkyrie::Persistence::Postgres::ORM::Resource
       end

data/lib/valkyrie/persistence/solr.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence
+  # Implements the DataMapper Pattern to store metadata into Solr
   module Solr
     require 'valkyrie/persistence/solr/metadata_adapter'
+    require 'valkyrie/persistence/solr/composite_indexer'
   end
 end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr
+  # Composite object to make multiple custom indexers act like a single one, so
+  # that upstream code doesn't have to know how to iterate over indexers.
+  #
+  # @see https://en.wikipedia.org/wiki/Composite_pattern
+  class CompositeIndexer
+    attr_reader :indexers
+    def initialize(*indexers)
+      @indexers = indexers
+    end
+
+    def new(resource:)
+      Instance.new(indexers, resource: resource)
+    end
+
+    class Instance
+      attr_reader :indexers, :resource
+      def initialize(indexers, resource:)
+        @resource = resource
+        @indexers = indexers.map { |i| i.new(resource: resource) }
+      end
+
+      def to_solr
+        indexers.map(&:to_solr).inject({}, &:merge)
+      end
+    end
+  end
+end

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

@@ -4,6 +4,28 @@ module Valkyrie::Persistence::Solr
   require 'valkyrie/persistence/solr/persister'
   require 'valkyrie/persistence/solr/query_service'
   require 'valkyrie/persistence/solr/resource_factory'
+  # MetadataAdapter for Solr Adapter.
+  #
+  # This adapter persists resources as hashes to an RSolr connection.
+  #
+  # @example Instantiate a Solr MetadataAdapter for Blacklight
+  #   Valkyrie::Persistence::Solr::MetadataAdapter.new(
+  #     connection: Blacklight.default_index.connection
+  #   )
+  #
+  # @example Instantiate a Solr MetadataAdapter with just RSolr
+  #   Valkyrie::Persistence::Solr::MetadataAdapter.new(
+  #     connection: RSolr.connect(url: "http://127.0.0.1:8983/solr/core")
+  #   )
+  #
+  # @example Instantiate a Solr MetadataAdapter with custom indexers
+  #   Valkyrie::Persistence::Solr::MetadataAdapter.new(
+  #     connection: Blacklight.default_index.connection,
+  #     resource_indexer: CompositeIndexer.new(
+  #       Valkyrie::Indexers::AccessControlsIndexer,
+  #       MyIndexer
+  #     )
+  #   )
   class MetadataAdapter
     attr_reader :connection, :resource_indexer
     # @param connection [RSolr::Client] The RSolr connection to index to.
@@ -22,7 +44,10 @@ module Valkyrie::Persistence::Solr
     # @return [Valkyrie::Persistence::Solr::QueryService] The solr query
     #   service.
     def query_service
-      Valkyrie::Persistence::Solr::QueryService.new(connection: connection, resource_factory: resource_factory)
+      @query_service ||= Valkyrie::Persistence::Solr::QueryService.new(
+        connection: connection,
+        resource_factory: resource_factory
+      )
     end
 
     # @return [Valkyrie::Persistence::Solr::ResourceFactory] A resource factory

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Solr
+  # Responsible for converting a {Valkyrie::Resource} into hashes for indexing
+  # into Solr.
   class ModelConverter
     attr_reader :resource, :resource_factory
     delegate :resource_indexer, to: :resource_factory
@@ -9,7 +11,8 @@ module Valkyrie::Persistence::Solr
     end
 
     def convert!
-      to_h.merge(internal_resource_ssim: [resource.internal_resource]).merge(indexer_solr(resource))
+      to_h.merge(Valkyrie::Persistence::Solr::Queries::MODEL.to_sym => [resource.internal_resource])
+          .merge(indexer_solr(resource))
     end
 
     def indexer_solr(resource)
@@ -18,19 +21,24 @@ module Valkyrie::Persistence::Solr
 
     # @return [String] The solr document ID
     def id
-      "id-#{resource.id}"
+      resource.id.to_s
     end
 
     # @return [String] ISO-8601 timestamp in UTC of the created_at for this solr
     #   document.
     def created_at
-      resource_attributes[:created_at] || Time.current.utc.iso8601
+      if resource_attributes[:created_at]
+        DateTime.parse(resource_attributes[:created_at].to_s).utc.iso8601
+      else
+        Time.current.utc.iso8601
+      end
     end
 
     # @return [Hash] Solr document to index.
     def to_h
       {
         "id": id,
+        "join_id_ssi": "id-#{id}",
         "created_at_dtsi": created_at
       }.merge(attribute_hash)
     end
@@ -39,12 +47,18 @@ module Valkyrie::Persistence::Solr
 
       def attribute_hash
         properties.each_with_object({}) do |property, hsh|
-          SolrMapperValue.for(Property.new(property, resource_attributes[property])).result.apply_to(hsh)
+          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
 
       def properties
-        resource_attributes.keys - [:id, :created_at, :updated_at]
+        resource_attributes.keys - [:id, :created_at, :updated_at, :new_record]
       end
 
       def resource_attributes
@@ -116,6 +130,18 @@ module Valkyrie::Persistence::Solr
       class SolrMapperValue < ::Valkyrie::ValueMapper
       end
 
+      # Casts {Boolean} values into a recognizable string in Solr.
+      class BooleanPropertyValue < ::Valkyrie::ValueMapper
+        SolrMapperValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && ([true, false].include? value.value)
+        end
+
+        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)
@@ -224,7 +250,8 @@ module Valkyrie::Persistence::Solr
           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}_lang", "eng")).result,
+              calling_mapper.for(Property.new("#{value.key}_type", "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")).result
             ]
           )
         end
@@ -258,10 +285,13 @@ module Valkyrie::Persistence::Solr
         end
 
         def result
+          key = value.key
+          val = value.value
           CompositeSolrRow.new(
             [
-              calling_mapper.for(Property.new(value.key, value.value.to_s)).result,
-              calling_mapper.for(Property.new("#{value.key}_lang", value.value.language.to_s)).result
+              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

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Solr
-  ##
-  # Converts a solr hash to a {Valkyrie::Resource}
+  # Responsible for converting hashes from Solr into a {Valkyrie::Resource}
   class ORMConverter
     attr_reader :solr_document
     def initialize(solr_document)
@@ -13,7 +12,7 @@ module Valkyrie::Persistence::Solr
     end
 
     def resource
-      resource_klass.new(attributes.symbolize_keys)
+      resource_klass.new(attributes.symbolize_keys.merge(new_record: false))
     end
 
     def resource_klass
@@ -21,7 +20,7 @@ module Valkyrie::Persistence::Solr
     end
 
     def internal_resource
-      solr_document["internal_resource_ssim"].first
+      solr_document.fetch(Valkyrie::Persistence::Solr::Queries::MODEL).first
     end
 
     def attributes
@@ -29,15 +28,15 @@ module Valkyrie::Persistence::Solr
     end
 
     def created_at
-      DateTime.parse(solr_document["created_at_dtsi"].to_s).utc
+      DateTime.parse(solr_document.fetch("created_at_dtsi").to_s).utc
     end
 
     def updated_at
-      DateTime.parse(solr_document["timestamp"] || solr_document["created_at_dtsi"].to_s).utc
+      DateTime.parse(solr_document["timestamp"] || solr_document.fetch("created_at_dtsi").to_s).utc
     end
 
     def id
-      solr_document["id"].gsub(/^id-/, '')
+      solr_document.fetch('id').sub(/^id-/, '')
     end
 
     def attribute_hash
@@ -49,7 +48,7 @@ module Valkyrie::Persistence::Solr
     def strip_tsim(hsh)
       Hash[
         hsh.map do |k, v|
-          [k.gsub("_tsim", ""), v]
+          [k.sub("_tsim", ""), v]
         end
       ]
     end
@@ -66,6 +65,7 @@ module Valkyrie::Persistence::Solr
     def build_literals(hsh)
       hsh.each_with_object({}) do |(key, value), output|
         next if key.end_with?("_lang")
+        next if key.end_with?("_type")
         output[key] = SolrValue.for(Property.new(key, value, hsh)).result
       end
     end
@@ -75,26 +75,36 @@ module Valkyrie::Persistence::Solr
 
     # Converts a stored language typed literal from two fields into one
     #   {RDF::Literal}
-    class LanguagePropertyValue < ::Valkyrie::ValueMapper
+    class RDFLiteralPropertyValue < ::Valkyrie::ValueMapper
       SolrValue.register(self)
       def self.handles?(value)
-        value.is_a?(Property) && value.document["#{value.key}_lang"]
+        value.is_a?(Property) &&
+          (value.document["#{value.key}_lang"] || value.document["#{value.key}_type"])
       end
 
       def result
-        value.value.zip(languages).map do |literal, language|
-          if language == "eng"
+        value.value.each_with_index.map do |literal, idx|
+          language = languages[idx]
+          type = datatypes[idx]
+          if language == "eng" && type == "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
             literal
+          elsif language.present?
+            RDF::Literal.new(literal, language: language, datatype: type)
           else
-            RDF::Literal.new(literal, language: language)
+            RDF::Literal.new(literal, datatype: type)
           end
         end
       end
 
       def languages
-        value.document["#{value.key}_lang"]
+        value.document.fetch("#{value.key}_lang", [])
+      end
+
+      def datatypes
+        value.document.fetch("#{value.key}_type", [])
       end
     end
+
     class PropertyValue < ::Valkyrie::ValueMapper
       SolrValue.register(self)
       def self.handles?(value)
@@ -126,7 +136,7 @@ module Valkyrie::Persistence::Solr
       end
 
       def result
-        Valkyrie::ID.new(value.gsub(/^id-/, ''))
+        Valkyrie::ID.new(value.sub(/^id-/, ''))
       end
     end
 
@@ -138,7 +148,7 @@ module Valkyrie::Persistence::Solr
       end
 
       def result
-        ::RDF::URI.new(value.gsub(/^uri-/, ''))
+        ::RDF::URI.new(value.sub(/^uri-/, ''))
       end
     end
 
@@ -154,7 +164,7 @@ module Valkyrie::Persistence::Solr
       end
 
       def json
-        value.gsub(/^serialized-/, '')
+        value.sub(/^serialized-/, '')
       end
     end
 
@@ -222,6 +232,19 @@ module Valkyrie::Persistence::Solr
       end
     end
 
+    # Converts an boolean in solr into an {Boolean}
+    class BooleanValue < ::Valkyrie::ValueMapper
+      SolrValue.register(self)
+      def self.handles?(value)
+        value.to_s.start_with?("boolean-")
+      end
+
+      def result
+        val = value.sub(/^boolean-/, '')
+        val.casecmp("true").zero?
+      end
+    end
+
     # Converts an integer in solr into an {Integer}
     class IntegerValue < ::Valkyrie::ValueMapper
       SolrValue.register(self)
@@ -230,7 +253,7 @@ module Valkyrie::Persistence::Solr
       end
 
       def result
-        value.gsub(/^integer-/, '').to_i
+        value.sub(/^integer-/, '').to_i
       end
     end
 
@@ -239,13 +262,13 @@ module Valkyrie::Persistence::Solr
       SolrValue.register(self)
       def self.handles?(value)
         return false unless value.to_s.start_with?("datetime-")
-        DateTime.iso8601(value.gsub(/^datetime-/, '')).utc
+        DateTime.iso8601(value.sub(/^datetime-/, '')).utc
       rescue
         false
       end
 
       def result
-        DateTime.parse(value.gsub(/^datetime-/, '')).utc
+        DateTime.parse(value.sub(/^datetime-/, '')).utc
       end
     end
   end