valkyrie 2.0.1 → 2.2.0

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

@@ -48,7 +48,7 @@ module Valkyrie::Persistence::Solr
     # Construct a Time object from the datestamp for the resource creation date indexed in Solr
     # @return [Time]
     def created_at
-      DateTime.parse(solr_document.fetch("created_at_dtsi").to_s).utc
+      DateTime.parse(solr_document.fetch("created_at_dtsi").to_s).new_offset(0)
     end
 
     # Construct a Time object from the datestamp for the date of the last resource update indexed in Solr
@@ -445,7 +445,7 @@ module Valkyrie::Persistence::Solr
       # @return [Boolean]
       def self.handles?(value)
         return false unless value.to_s.start_with?("datetime-")
-        DateTime.iso8601(value.sub(/^datetime-/, '')).utc
+        DateTime.iso8601(value.sub(/^datetime-/, '')).new_offset(0)
       rescue
         false
       end
@@ -453,7 +453,7 @@ module Valkyrie::Persistence::Solr
       # Parses and casts the Solr field value into a UTC DateTime value
       # @return [Time]
       def result
-        DateTime.parse(value.sub(/^datetime-/, '')).utc
+        DateTime.parse(value.sub(/^datetime-/, '')).new_offset(0)
       end
     end
   end

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

@@ -14,35 +14,22 @@ module Valkyrie::Persistence::Solr
       @adapter = adapter
     end
 
-    # Persists a Valkyrie Resource into a Solr index
-    # @note Fields are saved using Solr's dynamic fields functionality.
-    #   If the text has length > 1000, it is stored as *_tsim
-    #   otherwise it's stored as *_tsim, *_ssim, and *_tesim
-    #   e.g., a field called 'title' would be stored as 3 solr fields:
-    #     'title_tsim'
-    #     'title_ssim'
-    #     'title_tesim'
-    # @param [Valkyrie::Resource] resource
-    # @return [Valkyrie::Resource] the persisted resource
+    # (see Valkyrie::Persistence::Memory::Persister#save)
     def save(resource:)
       repository([resource]).persist.first
     end
 
-    # Persists a set of Valkyrie Resources into a Solr index
-    # @param [Array<Valkyrie::Resource>] resources
-    # @return [Valkyrie::Resource] the set of persisted resources
+    # (see Valkyrie::Persistence::Memory::Persister#save_all)
     def save_all(resources:)
       repository(resources).persist
     end
 
-    # Deletes a Valkyrie Resource persisted into a Solr index
-    # @param [Valkyrie::Resource] resource
-    # @return [Valkyrie::Resource] the deleted resource
+    # (see Valkyrie::Persistence::Memory::Persister#delete)
     def delete(resource:)
       repository([resource]).delete.first
     end
 
-    # Delete the Solr index of all Documents
+    # (see Valkyrie::Persistence::Memory::Persister#wipe!)
     def wipe!
       connection.delete_by_query("*:*")
       connection.commit

data/lib/valkyrie/persistence/solr/queries/find_all_query.rb

@@ -33,6 +33,12 @@ module Valkyrie::Persistence::Solr::Queries
       end
     end
 
+    # Queries without making Resrouces and returns the RSolr page_total value
+    # @return [Integer]
+    def count
+      connection.get("select", params: { q: query })["response"]["numFound"].to_s.to_i
+    end
+
     # Generates the Solr query for retrieving all Documents in the index
     # If a model is specified for the query, it is scoped to that Valkyrie resource type
     # @return [String]

data/lib/valkyrie/persistence/solr/queries/find_by_alternate_identifier_query.rb

@@ -32,7 +32,7 @@ module Valkyrie::Persistence::Solr::Queries
     # @note the field used here is alternate_ids_ssim and the value is prefixed by "id-"
     # @return [Hash]
     def resource
-      connection.get("select", params: { q: "alternate_ids_ssim:\"id-#{alternate_identifier}\"", fl: "*", rows: 1 })["response"]["docs"].first
+      @resource ||= connection.get("select", params: { q: "alternate_ids_ssim:\"id-#{alternate_identifier}\"", fl: "*", rows: 1 })["response"]["docs"].first
     end
   end
 end

data/lib/valkyrie/persistence/solr/queries/find_by_id_query.rb

@@ -31,7 +31,7 @@ module Valkyrie::Persistence::Solr::Queries
     # Query Solr for for the first document with the ID in a field
     # @return [Hash]
     def resource
-      connection.get("select", params: { q: "id:\"#{id}\"", fl: "*", rows: 1 })["response"]["docs"].first
+      @resource ||= connection.get("select", params: { q: "id:\"#{id}\"", fl: "*", rows: 1 })["response"]["docs"].first
     end
   end
 end

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

@@ -27,7 +27,7 @@ module Valkyrie::Persistence::Solr::Queries
     # Results are ordered by the member IDs specified in the Valkyrie Resource attribute
     # @yield [Valkyrie::Resource]
     def each
-      return [] unless resource.id.present?
+      return [] if resource.id.blank?
       member_ids.map { |id| unordered_members.find { |member| member.id == id } }.reject(&:nil?).each do |member|
         yield member
       end

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

@@ -12,27 +12,21 @@ module Valkyrie::Persistence::Solr
       @adapter = adapter
     end
 
-    # Find resources by Valkyrie ID
-    # @param [Valkyrie::ID] id
-    # @return [Valkyrie::Resource]
+    # (see Valkyrie::Persistence::Memory::QueryService#find_by)
     def find_by(id:)
       id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
       validate_id(id)
       Valkyrie::Persistence::Solr::Queries::FindByIdQuery.new(id, connection: connection, resource_factory: resource_factory).run
     end
 
-    # Find resources by a Valkyrie alternate identifier
-    # @param [Valkyrie::ID] alternate_identifier
-    # @return [Valkyrie::Resource]
+    # (see Valkyrie::Persistence::Memory::QueryService#find_by_alternate_identifier)
     def find_by_alternate_identifier(alternate_identifier:)
       alternate_identifier = Valkyrie::ID.new(alternate_identifier.to_s) if alternate_identifier.is_a?(String)
       validate_id(alternate_identifier)
       Valkyrie::Persistence::Solr::Queries::FindByAlternateIdentifierQuery.new(alternate_identifier, connection: connection, resource_factory: resource_factory).run
     end
 
-    # Find resources using a set of Valkyrie IDs
-    # @param [Array<Valkyrie::ID>] ids
-    # @return [Array<Valkyrie::Resource>]
+    # (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)
@@ -42,29 +36,29 @@ module Valkyrie::Persistence::Solr
       Valkyrie::Persistence::Solr::Queries::FindManyByIdsQuery.new(ids, connection: connection, resource_factory: resource_factory).run
     end
 
-    # Find all of the Valkyrie Resources persisted in the Solr index
-    # @return [Array<Valkyrie::Resource>]
+    # (see Valkyrie::Persistence::Memory::QueryService#find_all)
     def find_all
       Valkyrie::Persistence::Solr::Queries::FindAllQuery.new(connection: connection, resource_factory: resource_factory).run
     end
 
-    # Find all of the Valkyrie Resources of a model persisted in the Solr index
-    # @param [Class, String] model the Valkyrie::Resource Class
-    # @return [Array<Valkyrie::Resource>]
+    # (see Valkyrie::Persistence::Memory::QueryService#find_all_of_model)
     def find_all_of_model(model:)
       Valkyrie::Persistence::Solr::Queries::FindAllQuery.new(connection: connection, resource_factory: resource_factory, model: model).run
     end
 
-    # Find all of the parent resources for a given Valkyrie Resource
-    # @param [Valkyrie::Resource] member resource
-    # @return [Array<Valkyrie::Resource>] parent resources
+    # Count all of the Valkyrie Resources of a model persisted in the Solr index
+    # @param [Class, String] model the Valkyrie::Resource Class
+    # @return integer
+    def count_all_of_model(model:)
+      Valkyrie::Persistence::Solr::Queries::FindAllQuery.new(connection: connection, resource_factory: resource_factory, model: model).count
+    end
+
+    # (see Valkyrie::Persistence::Memory::QueryService#find_parents)
     def find_parents(resource:)
       find_inverse_references_by(resource: resource, property: :member_ids)
     end
 
-    # Find all of the member resources for a given Valkyrie Resource
-    # @param [Valkyrie::Resource] parent resource
-    # @return [Array<Valkyrie::Resource>] member resources
+    # (see Valkyrie::Persistence::Memory::QueryService#find_members)
     def find_members(resource:, model: nil)
       Valkyrie::Persistence::Solr::Queries::FindMembersQuery.new(
         resource: resource,
@@ -74,53 +68,48 @@ module Valkyrie::Persistence::Solr
       ).run
     end
 
-    # Find all of the resources referenced by a given Valkyrie Resource using a specific property
-    # @param [Valkyrie::Resource] resource
-    # @param [Symbol, String] property
-    # @return [Array<Valkyrie::Resource>] referenced resources
-    def find_references_by(resource:, property:)
-      if ordered_property?(resource: resource, property: property)
-        Valkyrie::Persistence::Solr::Queries::FindOrderedReferencesQuery.new(resource: resource, property: property, connection: connection, resource_factory: resource_factory).run
-      else
-        Valkyrie::Persistence::Solr::Queries::FindReferencesQuery.new(resource: resource, property: property, connection: connection, resource_factory: resource_factory).run
-      end
+    # (see Valkyrie::Persistence::Memory::QueryService#find_references_by)
+    def find_references_by(resource:, property:, model: nil)
+      result =
+        if ordered_property?(resource: resource, property: property)
+          Valkyrie::Persistence::Solr::Queries::FindOrderedReferencesQuery.new(resource: resource, property: property, connection: connection, resource_factory: resource_factory).run
+        else
+          Valkyrie::Persistence::Solr::Queries::FindReferencesQuery.new(resource: resource, property: property, connection: connection, resource_factory: resource_factory).run
+        end
+      return result unless model
+      result.select { |obj| obj.is_a?(model) }
     end
 
-    # Find all of the resources referencing a given Valkyrie Resource using a specific property
-    # (e. g. find all resources referencing a parent resource as a collection using the property "member_of_collections")
-    # @param [Valkyrie::Resource] referenced resource
-    # @param [Symbol, String] property
-    # @return [Array<Valkyrie::Resource>] related resources
-    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
-      Valkyrie::Persistence::Solr::Queries::FindInverseReferencesQuery.new(id: id, property: property, connection: connection, resource_factory: resource_factory).run
+      result = Valkyrie::Persistence::Solr::Queries::FindInverseReferencesQuery.new(id: id, property: property, connection: connection, resource_factory: resource_factory).run
+      return result unless model
+      result.select { |obj| obj.is_a?(model) }
     end
 
-    # Construct the Valkyrie::Persistence::CustomQueryContainer object using this query service
-    # @return [Valkyrie::Persistence::CustomQueryContainer]
+    # (see Valkyrie::Persistence::Memory::QueryService#custom_queries)
     def custom_queries
       @custom_queries ||= ::Valkyrie::Persistence::CustomQueryContainer.new(query_service: self)
     end
 
     private
 
-      # Determine whether or not a value is a Valkyrie ID
-      # @param [Object] id
-      # @return [Boolean]
-      def validate_id(id)
-        raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
-      end
+    # (see Valkyrie::Persistence::Memory::QueryService#validate_id)
+    def validate_id(id)
+      raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
+    end
 
-      # Ensure that a given Valkyrie Resource has been persisted
-      # @param [Valkyrie::Resource] resource
-      def ensure_persisted(resource)
-        raise ArgumentError, 'resource is not saved' unless resource.persisted?
-      end
+    # (see Valkyrie::Persistence::Memory::QueryService#ensure_persisted)
+    def ensure_persisted(resource)
+      raise ArgumentError, 'resource is not saved' unless resource.persisted?
+    end
 
-      def ordered_property?(resource:, property:)
-        resource.ordered_attribute?(property)
-      end
+    # (see Valkyrie::Persistence::Memory::QueryService#ordered_property?)
+    def ordered_property?(resource:, property:)
+      resource.ordered_attribute?(property)
+    end
   end
 end

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

@@ -62,8 +62,9 @@ module Valkyrie::Persistence::Solr
     # Given a new Valkyrie Resource, generate a random UUID and assign it to the Resource
     # @param [Valkyrie::Resource] resource
     # @param [String] the UUID for the new resource
+    # @see Valkyrie::Logging for details concerning log suppression.
     def generate_id(resource)
-      Valkyrie.logger.warn "The Solr adapter is not meant to persist new resources, but is now generating an ID."
+      Valkyrie.logger.warn("The Solr adapter is not meant to persist new resources, but is now generating an ID.", logging_context: "Valkyrie::Persistence::Solr::Repository#generate_id")
       resource.id = SecureRandom.uuid
     end
 

data/lib/valkyrie/rdf_patches.rb

@@ -6,12 +6,12 @@
 module RDF
   class Literal
     def as_json(*_args)
-      JSON::LD::API.fromRdf([RDF::Statement.new(RDF::URI(""), RDF::URI(""), self)])[0][""][0]
+      ::JSON::LD::API.fromRdf([RDF::Statement.new(RDF::URI(""), RDF::URI(""), self)])[0][""][0]
     end
   end
   class URI
     def as_json(*_args)
-      JSON::LD::API.fromRdf([RDF::Statement.new(RDF::URI(""), RDF::URI(""), self)])[0][""][0]
+      ::JSON::LD::API.fromRdf([RDF::Statement.new(RDF::URI(""), RDF::URI(""), self)])[0][""][0]
     end
   end
 end

data/lib/valkyrie/resource.rb

@@ -13,6 +13,7 @@ module Valkyrie
   # @see https://github.com/samvera-labs/valkyrie/wiki/ChangeSets-and-Dirty-Tracking Validation and change tracking is provided by change sets
   #
   # @see lib/valkyrie/specs/shared_specs/resource.rb
+  # rubocop:disable Metrics/ClassLength
   class Resource < Dry::Struct
     include Draper::Decoratable
     # Allows a Valkyrie::Resource to be instantiated without providing every
@@ -48,13 +49,38 @@ module Valkyrie
       raise ReservedAttributeError, "#{name} is a reserved attribute and defined by Valkyrie::Resource, do not redefine it." if reserved_attributes.include?(name.to_sym) &&
                                                                                                                                 attribute_names.include?(name.to_sym) &&
                                                                                                                                 !internal
-      define_method("#{name}=") do |value|
-        set_value(name, value)
-      end
-      type = type.meta(ordered: true) if name == :member_ids
+
       super(name, type)
     end
 
+    # @param [Hash{Symbol => Dry::Types::Type}] new_schema
+    # @return [Dry::Struct]
+    # @raise [RepeatedAttributeError] when trying to define attribute with the
+    #   same name as previously defined one
+    # @raise [ReservedAttributeError] when trying to define an attribute
+    #   reserved by Valkyrie
+    # @see #attribute
+    # @note extends {Dry::Struct} by adding `#attr=` style setters
+    def self.attributes(new_schema)
+      new_schema[:member_ids] = new_schema[:member_ids].meta(ordered: true) if
+        new_schema.key?(:member_ids)
+
+      super
+
+      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
+
     def self.reserved_attributes
       [:id, :internal_resource, :created_at, :updated_at, :new_record]
     end
@@ -87,6 +113,10 @@ module Valkyrie
       self.class.optimistic_locking_enabled?
     end
 
+    def clear_optimistic_lock_token!
+      send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", []) if optimistic_locking_enabled?
+    end
+
     def attributes
       Hash[self.class.attribute_names.map { |x| [x, nil] }].merge(super).freeze
     end
@@ -161,9 +191,10 @@ module Valkyrie
 
     # Returns if an attribute is set as ordered.
     def ordered_attribute?(key)
-      self.class.schema.key(key).type.meta.try(:[], :ordered)
+      self.class.schema.key(key.to_sym).type.meta.try(:[], :ordered)
     end
 
     class ReservedAttributeError < StandardError; end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/valkyrie/specs/shared_specs/change_set.rb

@@ -75,7 +75,7 @@ RSpec.shared_examples 'a Valkyrie::ChangeSet' do |*_flags|
 
   describe "#optimistic_locking_enabled?" do
     it "delegates down to the resource" do
-      expect(change_set.optimistic_locking_enabled?).to eq false
+      expect(change_set.optimistic_locking_enabled?).to eq change_set.resource.optimistic_locking_enabled?
     end
   end
 end

data/lib/valkyrie/specs/shared_specs/persister.rb

@@ -56,6 +56,14 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     output = persister.save(resource: resource)
 
     expect(output.single_value).to eq "A single value"
+
+    reloaded = query_service.find_by(id: output.id)
+
+    reloaded.single_value = nil
+    persister.save(resource: reloaded)
+    reloaded = query_service.find_by(id: reloaded.id)
+
+    expect(reloaded.single_value).to eq nil
   end
 
   it "returns nil for an unset single value" do
@@ -76,14 +84,14 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
 
   it "can support deep nesting of resources" do
     pending "No support for deep nesting." if flags.include?(:no_deep_nesting)
-    book = resource_class.new(title: "Sub-nested", author: [Valkyrie::ID.new("test"), RDF::Literal.new("Test", language: :fr), RDF::URI("http://test.com")])
+    book = resource_class.new(title: "Sub-nested", author: [Valkyrie::ID.new("test"), RDF::Literal.new("Test", language: :fr), RDF::URI("http://example.com")])
     book2 = resource_class.new(title: "Nested", nested_resource: book)
     book3 = persister.save(resource: resource_class.new(nested_resource: book2))
 
     reloaded = query_service.find_by(id: book3.id)
     expect(reloaded.nested_resource.first.title).to eq ["Nested"]
     expect(reloaded.nested_resource.first.nested_resource.first.title).to eq ["Sub-nested"]
-    expect(reloaded.nested_resource.first.nested_resource.first.author).to contain_exactly Valkyrie::ID.new("test"), RDF::Literal.new("Test", language: :fr), RDF::URI("http://test.com")
+    expect(reloaded.nested_resource.first.nested_resource.first.author).to contain_exactly Valkyrie::ID.new("test"), RDF::Literal.new("Test", language: :fr), RDF::URI("http://example.com")
   end
 
   it "stores created_at/updated_at" do
@@ -186,9 +194,9 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     reloaded = query_service.find_by(id: book.id)
 
     expect(reloaded.title.first.to_i).to eq(time1.to_i)
-    expect(reloaded.title.first.zone).to eq('UTC')
+    expect(reloaded.title.first.zone).to eq('+00:00')
     expect(reloaded.author.first.to_i).to eq(time2.to_i)
-    expect(reloaded.author.first.zone).to eq('UTC')
+    expect(reloaded.author.first.zone).to eq('+00:00')
     expect(reloaded.other_author.first).to eq "2019-01"
   end
 
@@ -352,7 +360,7 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
           resource = MyLockingResource.new(title: ["My Locked Resource"])
           initial_resource = persister.save(resource: resource)
           initial_token = initial_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first
-          initial_resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", [])
+          initial_resource.clear_optimistic_lock_token!
           updated_resource = persister.save(resource: initial_resource)
           expect(initial_token.serialize)
             .not_to eq(updated_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first.serialize)

data/lib/valkyrie/specs/shared_specs/queries.rb

@@ -12,10 +12,15 @@ RSpec.shared_examples 'a Valkyrie query provider' do
     end
     class Valkyrie::Specs::SecondResource < Valkyrie::Resource
     end
+    class Valkyrie::Specs::ThirdResource < Valkyrie::Resource
+      attribute :a_member_of, Valkyrie::Types::Array
+      attribute :an_ordered_member_of, Valkyrie::Types::Array.meta(ordered: true)
+    end
   end
   after do
     Valkyrie::Specs.send(:remove_const, :CustomResource)
     Valkyrie::Specs.send(:remove_const, :SecondResource)
+    Valkyrie::Specs.send(:remove_const, :ThirdResource)
   end
   let(:resource_class) { Valkyrie::Specs::CustomResource }
   let(:query_service) { adapter.query_service } unless defined? query_service
@@ -28,10 +33,11 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   it { is_expected.to respond_to(:find_by_alternate_identifier).with_keywords(:alternate_identifier) }
   it { is_expected.to respond_to(:find_many_by_ids).with_keywords(:ids) }
   it { is_expected.to respond_to(:find_members).with_keywords(:resource, :model) }
-  it { is_expected.to respond_to(:find_references_by).with_keywords(:resource, :property) }
-  it { is_expected.to respond_to(:find_inverse_references_by).with_keywords(:resource, :property) }
-  it { is_expected.to respond_to(:find_inverse_references_by).with_keywords(:id, :property) }
+  it { is_expected.to respond_to(:find_references_by).with_keywords(:resource, :property, :model) }
+  it { is_expected.to respond_to(:find_inverse_references_by).with_keywords(:resource, :property, :model) }
+  it { is_expected.to respond_to(:find_inverse_references_by).with_keywords(:id, :property, :model) }
   it { is_expected.to respond_to(:find_parents).with_keywords(:resource) }
+  it { is_expected.to respond_to(:count_all_of_model).with_keywords(:model) }
 
   describe ".find_all" do
     it "returns all created resources" do
@@ -273,14 +279,50 @@ RSpec.shared_examples 'a Valkyrie query provider' do
         expect(query_service.find_references_by(resource: child, property: :an_ordered_member_of).map(&:id).to_a).to eq []
       end
     end
+
+    context "filtering by model" do
+      context "when the object has related resources that match the filter" do
+        subject { query_service.find_references_by(resource: child1, property: :a_member_of, model: Valkyrie::Specs::SecondResource) }
+        let(:child1) { persister.save(resource: Valkyrie::Specs::ThirdResource.new(a_member_of: [parent3.id, parent2.id, parent.id])) }
+        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+        let(:parent2) { persister.save(resource: Valkyrie::Specs::CustomResource.new) }
+        let(:parent3) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+
+        it "returns only resources with the relationship filtered to the specified model" do
+          expect(subject.map(&:id).to_a).to match_array [parent3.id, parent.id]
+        end
+      end
+
+      context "when the object has ordered related resources that match the filter" do
+        subject { query_service.find_references_by(resource: child1, property: :an_ordered_member_of, model: Valkyrie::Specs::SecondResource) }
+        let(:child1) { persister.save(resource: Valkyrie::Specs::ThirdResource.new(an_ordered_member_of: [parent.id, parent3.id, parent2.id, parent.id])) }
+        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+        let(:parent2) { persister.save(resource: Valkyrie::Specs::CustomResource.new) }
+        let(:parent3) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+
+        it "returns only resources with the relationship filtered to the specified model" do
+          expect(subject.map(&:id).to_a).to match_array [parent.id, parent3.id, parent.id]
+        end
+      end
+
+      context "when there are no related resources that match the filter" do
+        subject { query_service.find_references_by(resource: child1, property: :a_member_of, model: Valkyrie::Specs::SecondResource) }
+        let(:child1) { persister.save(resource: Valkyrie::Specs::ThirdResource.new(a_member_of: [parent.id])) }
+        let(:parent) { persister.save(resource: Valkyrie::Specs::CustomResource.new) }
+
+        it "returns an empty array" do
+          expect(subject.to_a).to eq []
+        end
+      end
+    end
   end
 
   describe ".find_inverse_references_by" do
     context "when the resource is saved" do
       context "when the property is unordered" do
         it "returns everything which references the given resource by the given property" do
-          parent = persister.save(resource: resource_class.new)
-          parent2 = persister.save(resource: resource_class.new)
+          parent = persister.save(resource: Valkyrie::Specs::SecondResource.new)
+          parent2 = persister.save(resource: Valkyrie::Specs::SecondResource.new)
           child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
           child2 = persister.save(resource: resource_class.new(a_member_of: [parent.id, parent2.id, parent.id]))
           persister.save(resource: resource_class.new)
@@ -290,7 +332,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
         end
 
         it "returns an empty array if there are none" do
-          parent = persister.save(resource: resource_class.new)
+          parent = persister.save(resource: Valkyrie::Specs::SecondResource.new)
 
           expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a).to eq []
         end
@@ -298,7 +340,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
 
       context "when the property is ordered" do
         it "returns everything which references the given resource by the given property" do
-          parent = persister.save(resource: resource_class.new)
+          parent = persister.save(resource: Valkyrie::Specs::SecondResource.new)
           child = persister.save(resource: resource_class.new(an_ordered_member_of: [parent.id]))
           child2 = persister.save(resource: resource_class.new(an_ordered_member_of: [parent.id, parent.id]))
           persister.save(resource: resource_class.new)
@@ -307,12 +349,38 @@ RSpec.shared_examples 'a Valkyrie query provider' do
           expect(query_service.find_inverse_references_by(resource: parent, property: :an_ordered_member_of).map(&:id).to_a).to contain_exactly child.id, child2.id
         end
       end
+
+      context "when the property is ordered for one child but not the other" do
+        before do
+          class Valkyrie::Specs::Parent < Valkyrie::Resource; end
+          class Valkyrie::Specs::ChildWithUnorderedParents < Valkyrie::Resource
+            attribute :a_member_of, Valkyrie::Types::Array
+          end
+          class Valkyrie::Specs::ChildWithOrderedParents < Valkyrie::Resource
+            attribute :a_member_of, Valkyrie::Types::Array.meta(ordered: true)
+          end
+        end
+        after do
+          Valkyrie::Specs.send(:remove_const, :Parent)
+          Valkyrie::Specs.send(:remove_const, :ChildWithUnorderedParents)
+          Valkyrie::Specs.send(:remove_const, :ChildWithOrderedParents)
+        end
+        it "returns" do
+          parent = persister.save(resource: Valkyrie::Specs::Parent.new)
+          child = persister.save(resource: Valkyrie::Specs::ChildWithUnorderedParents.new(a_member_of: [parent.id]))
+          child2 = persister.save(resource: Valkyrie::Specs::ChildWithOrderedParents.new(a_member_of: [parent.id, parent.id]))
+          persister.save(resource: Valkyrie::Specs::ChildWithUnorderedParents.new)
+          persister.save(resource: Valkyrie::Specs::Parent.new)
+
+          expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).map(&:id).to_a).to contain_exactly child.id, child2.id
+        end
+      end
     end
 
     context "when id is passed instead of resource" do
       it "returns everything which references the given resource by the given property" do
-        parent = persister.save(resource: resource_class.new)
-        parent2 = persister.save(resource: resource_class.new)
+        parent = persister.save(resource: Valkyrie::Specs::SecondResource.new)
+        parent2 = persister.save(resource: Valkyrie::Specs::SecondResource.new)
         child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
         child2 = persister.save(resource: resource_class.new(a_member_of: [parent.id, parent2.id, parent.id]))
         persister.save(resource: resource_class.new)
@@ -335,6 +403,32 @@ RSpec.shared_examples 'a Valkyrie query provider' do
         expect { query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a }.to raise_error ArgumentError
       end
     end
+
+    context "filtering by model" do
+      subject { query_service.find_inverse_references_by(resource: parent, property: :a_member_of, model: Valkyrie::Specs::CustomResource) }
+
+      context "when the object has related resources that match the filter" do
+        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+
+        it "returns only resources with the relationship filtered to the specified model" do
+          child1 = persister.save(resource: Valkyrie::Specs::CustomResource.new(a_member_of: [parent.id]))
+          persister.save(resource: Valkyrie::Specs::ThirdResource.new(a_member_of: [parent.id]))
+          child3 = persister.save(resource: Valkyrie::Specs::CustomResource.new(a_member_of: [parent.id]))
+
+          expect(subject.map(&:id).to_a).to match_array [child3.id, child1.id]
+        end
+      end
+
+      context "when there are no related resources that match the filter" do
+        let(:parent) { persister.save(resource: Valkyrie::Specs::SecondResource.new) }
+
+        it "returns an empty array" do
+          persister.save(resource: Valkyrie::Specs::ThirdResource.new(a_member_of: [parent.id]))
+
+          expect(subject.to_a).to eq []
+        end
+      end
+    end
   end
 
   describe ".find_parents" do
@@ -411,4 +505,13 @@ RSpec.shared_examples 'a Valkyrie query provider' do
       expect(resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]).not_to be_empty
     end
   end
+
+  describe ".count_all_of_model" do
+    it "counts all of that model" do
+      persister.save(resource: resource_class.new)
+      persister.save(resource: Valkyrie::Specs::SecondResource.new)
+      persister.save(resource: Valkyrie::Specs::SecondResource.new)
+      expect(query_service.count_all_of_model(model: Valkyrie::Specs::SecondResource)).to eq(2)
+    end
+  end
 end