valkyrie 0.0.0 → 0.1.0

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'valkyrie/persistence/postgres/orm'
+require 'valkyrie/persistence/postgres/resource_factory'
+module Valkyrie::Persistence::Postgres
+  class Persister
+    attr_reader :adapter
+    delegate :resource_factory, to: :adapter
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#save)
+    def save(resource:)
+      orm_object = resource_factory.from_resource(resource: resource)
+      orm_object.save!
+      resource_factory.to_resource(object: orm_object)
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#save_all)
+    def save_all(resources:)
+      resources.map do |resource|
+        save(resource: resource)
+      end
+    end
+
+    # (see Valkyrie::Persistence::Memory::Persister#delete)
+    def delete(resource:)
+      orm_object = resource_factory.from_resource(resource: resource)
+      orm_object.delete
+      resource
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'valkyrie/persistence/postgres/queries/find_inverse_references_query'
+require 'valkyrie/persistence/postgres/queries/find_members_query'
+require 'valkyrie/persistence/postgres/queries/find_references_query'
+module Valkyrie::Persistence::Postgres
+  module Queries
+  end
+end

data/lib/valkyrie/persistence/postgres/queries/find_inverse_references_query.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Postgres::Queries
+  class FindInverseReferencesQuery
+    delegate :orm_class, to: :resource_factory
+    attr_reader :obj, :property, :resource_factory
+    def initialize(obj, property, resource_factory:)
+      @obj = obj
+      @property = property
+      @resource_factory = resource_factory
+    end
+
+    def run
+      relation.lazy.map do |orm_object|
+        resource_factory.to_resource(object: orm_object)
+      end
+    end
+
+    private
+
+      def relation
+        orm_class.find_by_sql([query, property, "[{\"id\": \"#{obj.id}\"}]"])
+      end
+
+      def query
+        <<-SQL
+        SELECT * FROM orm_resources WHERE
+        metadata->? @> ?
+      SQL
+      end
+  end
+end

data/lib/valkyrie/persistence/postgres/queries/find_members_query.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Postgres::Queries
+  class FindMembersQuery
+    attr_reader :obj, :resource_factory
+    delegate :orm_class, to: :resource_factory
+    def initialize(obj, resource_factory:)
+      @obj = obj
+      @resource_factory = resource_factory
+    end
+
+    def run
+      return [] if obj.id.blank?
+      relation.lazy.map do |orm_object|
+        resource_factory.to_resource(object: orm_object)
+      end
+    end
+
+    private
+
+      def relation
+        orm_class.find_by_sql([query, obj.id.to_s])
+      end
+
+      def 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')::uuid = member.id WHERE a.id = ?
+        ORDER BY b.member_pos
+      SQL
+      end
+  end
+end

data/lib/valkyrie/persistence/postgres/queries/find_references_query.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Postgres::Queries
+  class FindReferencesQuery
+    delegate :orm_class, to: :resource_factory
+    attr_reader :obj, :property, :resource_factory
+    def initialize(obj, property, resource_factory:)
+      @obj = obj
+      @property = property
+      @resource_factory = resource_factory
+    end
+
+    def run
+      return [] if obj.id.blank? || obj[property].blank?
+      relation.lazy.map do |orm_object|
+        resource_factory.to_resource(object: orm_object)
+      end
+    end
+
+    private
+
+      def relation
+        orm_class.find_by_sql([query, property, obj.id.to_s])
+      end
+
+      def query
+        <<-SQL
+        SELECT member.* FROM orm_resources a,
+        jsonb_array_elements(a.metadata->?) AS b(member)
+        JOIN orm_resources member ON (b.member->>'id')::uuid = member.id WHERE a.id = ?
+      SQL
+      end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require 'valkyrie/persistence/postgres/queries'
+module Valkyrie::Persistence::Postgres
+  class QueryService
+    attr_reader :adapter
+    delegate :resource_factory, to: :adapter
+    delegate :orm_class, to: :resource_factory
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_all)
+    def find_all
+      orm_class.all.lazy.map do |orm_object|
+        resource_factory.to_resource(object: orm_object)
+      end
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_all_of_model)
+    def find_all_of_model(model:)
+      orm_class.where(internal_resource: model.to_s).lazy.map do |orm_object|
+        resource_factory.to_resource(object: orm_object)
+      end
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_by)
+    def find_by(id:)
+      resource_factory.to_resource(object: orm_class.find(id))
+    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
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_parents)
+    def find_parents(resource:)
+      find_inverse_references_by(resource: resource, property: :member_ids)
+    end
+
+    # (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
+    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
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Postgres
+  class ResourceConverter
+    delegate :orm_class, to: :resource_factory
+    attr_reader :resource, :resource_factory
+    def initialize(resource, resource_factory:)
+      @resource = resource
+      @resource_factory = resource_factory
+    end
+
+    def convert!
+      orm_class.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
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require 'valkyrie/persistence/postgres/orm_converter'
+require 'valkyrie/persistence/postgres/resource_converter'
+module Valkyrie::Persistence::Postgres
+  class ResourceFactory
+    class << self
+      # @param orm_object [Valkyrie::Persistence::Postgres::ORM::Resource] AR
+      #   record to be converted.
+      # @return [Valkyrie::Resource] Model representation of the AR record.
+      def to_resource(object:)
+        ::Valkyrie::Persistence::Postgres::ORMConverter.new(object).convert!
+      end
+
+      # @param resource [Valkyrie::Resource] Model to be converted to ActiveRecord.
+      # @return [Valkyrie::Persistence::Postgres::ORM::Resource] ActiveRecord
+      #   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
+
+      def orm_class
+        ::Valkyrie::Persistence::Postgres::ORM::Resource
+      end
+    end
+  end
+end

data/lib/valkyrie/persistence/solr.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence
+  module Solr
+    require 'valkyrie/persistence/solr/metadata_adapter'
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require 'rsolr'
+module Valkyrie::Persistence::Solr
+  require 'valkyrie/persistence/solr/persister'
+  require 'valkyrie/persistence/solr/query_service'
+  require 'valkyrie/persistence/solr/resource_factory'
+  class MetadataAdapter
+    attr_reader :connection, :resource_indexer
+    # @param connection [RSolr::Client] The RSolr connection to index to.
+    # @param resource_indexer [Class, #to_solr] An indexer which is able to
+    #   receive a `resource` argument and then has an instance method `#to_solr`
+    def initialize(connection:, resource_indexer: NullIndexer)
+      @connection = connection
+      @resource_indexer = resource_indexer
+    end
+
+    # @return [Valkyrie::Persistence::Solr::Persister] The solr persister.
+    def persister
+      Valkyrie::Persistence::Solr::Persister.new(adapter: self)
+    end
+
+    # @return [Valkyrie::Persistence::Solr::QueryService] The solr query
+    #   service.
+    def query_service
+      Valkyrie::Persistence::Solr::QueryService.new(connection: connection, resource_factory: resource_factory)
+    end
+
+    # @return [Valkyrie::Persistence::Solr::ResourceFactory] A resource factory
+    #   to convert a resource to a solr document and back.
+    def resource_factory
+      Valkyrie::Persistence::Solr::ResourceFactory.new(resource_indexer: resource_indexer)
+    end
+
+    class NullIndexer
+      def initialize(_); end
+
+      def to_solr
+        {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence::Solr
+  class ModelConverter
+    attr_reader :resource, :resource_factory
+    delegate :resource_indexer, to: :resource_factory
+    def initialize(resource, resource_factory:)
+      @resource = resource
+      @resource_factory = resource_factory
+    end
+
+    def convert!
+      to_h.merge(internal_resource_ssim: [resource.internal_resource]).merge(indexer_solr(resource))
+    end
+
+    def indexer_solr(resource)
+      resource_indexer.new(resource: resource).to_solr
+    end
+
+    # @return [String] The solr document ID
+    def id
+      "id-#{resource.id}"
+    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
+    end
+
+    # @return [Hash] Solr document to index.
+    def to_h
+      {
+        "id": id,
+        "created_at_dtsi": created_at
+      }.merge(attribute_hash)
+    end
+
+    private
+
+      def attribute_hash
+        properties.each_with_object({}) do |property, hsh|
+          SolrMapperValue.for(Property.new(property, resource_attributes[property])).result.apply_to(hsh)
+        end
+      end
+
+      def properties
+        resource_attributes.keys - [:id, :created_at, :updated_at]
+      end
+
+      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
+
+        # @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
+        def initialize(solr_rows)
+          @solr_rows = solr_rows
+        end
+
+        # @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
+
+      # Casts nested resources into a JSON string in solr.
+      class NestedObjectValue < ::Valkyrie::ValueMapper
+        SolrMapperValue.register(self)
+        def self.handles?(value)
+          value.value.is_a?(Hash)
+        end
+
+        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)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(Array)
+        end
+
+        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)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.nil?
+        end
+
+        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)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(::Valkyrie::ID)
+        end
+
+        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)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(::RDF::URI)
+        end
+
+        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)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(Integer)
+        end
+
+        def result
+          calling_mapper.for(Property.new(value.key, "integer-#{value.value}")).result
+        end
+      end
+
+      # Casts {DateTime} values into a recognizable string in Solr.
+      class DateTimePropertyValue < ::Valkyrie::ValueMapper
+        SolrMapperValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && (value.value.is_a?(Time) || value.value.is_a?(DateTime))
+        end
+
+        def result
+          calling_mapper.for(Property.new(value.key, "datetime-#{JSON.parse(to_datetime(value.value).to_json)}")).result
+        end
+
+        private
+
+          def to_datetime(value)
+            return value.utc if value.is_a?(DateTime)
+            return value.to_datetime.utc 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)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(String) && value.scope.find { |x| x.is_a?(::RDF::Literal) }.present?
+        end
+
+        def result
+          CompositeSolrRow.new(
+            [
+              calling_mapper.for(Property.new(value.key, value.value)).result,
+              calling_mapper.for(Property.new("#{value.key}_lang", "eng")).result
+            ]
+          )
+        end
+      end
+
+      # Handles casting strings.
+      class StringPropertyValue < ::Valkyrie::ValueMapper
+        SolrMapperValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(String)
+        end
+
+        def result
+          SolrRow.new(key: value.key, fields: fields, values: value.value)
+        end
+
+        def fields
+          if value.value.length > 1000
+            [:tsim]
+          else
+            [:tsim, :ssim, :tesim]
+          end
+        end
+      end
+
+      # Handles casting language-typed {RDF::Literal}s
+      class LiteralPropertyValue < ::Valkyrie::ValueMapper
+        SolrMapperValue.register(self)
+        def self.handles?(value)
+          value.is_a?(Property) && value.value.is_a?(::RDF::Literal)
+        end
+
+        def result
+          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
+            ]
+          )
+        end
+      end
+  end
+end