valkyrie 2.0.2 → 2.1.0

data/lib/valkyrie/persistence/fedora/permissive_schema.rb

@@ -6,8 +6,8 @@ module Valkyrie::Persistence::Fedora
   #
   # @example Passing in a mapping
   #   schema = Valkyrie::Persistence::Fedora::PermissiveSchema.new(member_ids:
-  #     RDF::URI("http://mypredicates.com/member_ids"))
-  #   schema.predicate_for(resource: Resource.new, property: :member_ids) # => RDF::URI<"http://mypredicates.com/member_ids">
+  #     RDF::URI("http://example.com/member_ids"))
+  #   schema.predicate_for(resource: Resource.new, property: :member_ids) # => RDF::URI<"http://example.com/member_ids">
   #   schema.predicate_for(resource: Resource.new, property: :unknown) # => RDF::URI<"http://example.com/predicate/unknown">
   class PermissiveSchema
     URI_PREFIX = 'http://example.com/predicate/'

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

@@ -64,11 +64,12 @@ module Valkyrie::Persistence::Fedora
     # (see Valkyrie::Persistence::Memory::Persister#wipe!)
     # Deletes Fedora repository resource *and* the tombstone resources which remain
     # @see https://wiki.duraspace.org/display/FEDORA4x/RESTful+HTTP+API#RESTfulHTTPAPI-RedDELETEDeletearesource
+    # @see Valkyrie::Logging for details concerning log suppression.
     def wipe!
       connection.delete(base_path)
       connection.delete("#{base_path}/fcr:tombstone")
     rescue => error
-      Valkyrie.logger.debug("Failed to wipe Fedora for some reason: #{error}") unless error.is_a?(::Ldp::NotFound)
+      Valkyrie.logger.debug("Failed to wipe Fedora for some reason: #{error}", logging_context: "Valkyrie::Persistence::Fedora::Persister#wipe") unless error.is_a?(::Ldp::NotFound)
     end
 
     # Creates the root LDP Container for the connection with Fedora

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

@@ -86,11 +86,18 @@ module Valkyrie::Persistence::Fedora
       end
     end
 
+    # (see Valkyrie::Persistence::Memory::QueryService#count_all_of_model)
+    def count_all_of_model(model:)
+      find_all_of_model(model: model).count
+    end
+
     # (see Valkyrie::Persistence::Memory::QueryService#find_references_by)
-    def find_references_by(resource:, property:)
-      (resource[property] || []).select { |x| x.is_a?(Valkyrie::ID) }.lazy.map do |id|
+    def find_references_by(resource:, property:, model: nil)
+      objects = (resource[property] || []).select { |x| x.is_a?(Valkyrie::ID) }.lazy.map do |id|
         find_by(id: id)
       end
+      return objects unless model
+      objects.select { |obj| obj.is_a?(model) }
     end
 
     # Retrieves the RDF graph for the LDP container for a resource
@@ -111,15 +118,16 @@ module Valkyrie::Persistence::Fedora
     # Find all resources referencing a given resource (e. g. parents)
     # *This is done by iterating through the ID of each resource referencing the resource in the query, and requesting each resource over the HTTP*
     # *Also, an initial request is made to find the URIs of the resources referencing the resource in the query*
-    def find_inverse_references_by(resource: nil, id: nil, property:)
+    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
       resource ||= find_by(id: id)
-      if ordered_property?(resource: resource, property: property)
-        find_inverse_references_by_ordered(resource: resource, property: property)
-      else
-        find_inverse_references_by_unordered(resource: resource, property: property)
-      end
+      ids = find_inverse_reference_ids_by_unordered(resource: resource, property: property).uniq
+      objects_from_unordered = ids.lazy.map { |ref_id| find_by(id: ref_id) }
+      objects_from_ordered = find_inverse_references_by_ordered(resource: resource, property: property, ignore_ids: ids)
+      objects = [objects_from_unordered, objects_from_ordered].lazy.flat_map(&:lazy)
+      return objects unless model
+      objects.select { |obj| obj.is_a?(model) }
     end
 
     # (see Valkyrie::Persistence::Memory::QueryService#custom_queries)
@@ -129,18 +137,17 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      def find_inverse_references_by_unordered(resource:, property:)
+      def find_inverse_reference_ids_by_unordered(resource:, property:)
         content = content_with_inbound(id: resource.id)
         property_uri = adapter.schema.predicate_for(property: property, resource: nil)
-        ids = content.graph.query([nil, property_uri, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
-        ids.uniq!
-        ids.lazy.map { |id| find_by(id: id) }
+        content.graph.query([nil, property_uri, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
       end
 
-      def find_inverse_references_by_ordered(resource:, property:)
+      def find_inverse_references_by_ordered(resource:, property:, ignore_ids: [])
         content = content_with_inbound(id: resource.id)
         ids = content.graph.query([nil, ::RDF::Vocab::ORE.proxyFor, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
         ids.uniq!
+        ids.delete_if { |id| ignore_ids.include? id }
         ids.lazy.map { |id| find_by(id: id) }.select { |o| o[property].include?(resource.id) }
       end
 
@@ -169,9 +176,5 @@ module Valkyrie::Persistence::Fedora
       def ensure_persisted(resource)
         raise ArgumentError, 'resource is not saved' unless resource.persisted?
       end
-
-      def ordered_property?(resource:, property:)
-        resource.ordered_attribute?(property)
-      end
   end
 end

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 module Valkyrie::Persistence::Memory
+  # Query Service for the memory metadata adapter.
+  # @see Valkyrie::Persistence::Memory
+  # @note Documentation for Query Services in general is maintained here.
   class QueryService
-    # Query Service for the memory metadata adapter.
-    # @see Valkyrie::Persistence::Memory
-    # @note Documentation for Query Services in general is maintained here.
     attr_reader :adapter, :query_handlers
     delegate :cache, to: :adapter
 
@@ -27,7 +27,9 @@ module Valkyrie::Persistence::Memory
       cache[id] || raise(::Valkyrie::Persistence::ObjectNotFoundError)
     end
 
-    # Get a single resource by `alternate_identifier`.
+    # Get a single resource by `alternate_identifier`. Alternate identifiers are identifiers (like NOIDs,
+    # DOIs, ARKs, etc.) that are not the system-generated ID, but might be used to identify a resource in an
+    # application (e.g., to make shorter URLs).
     # @param alternate_identifier [Valkyrie::ID] The alternate identifier to query for.
     # @raise [Valkyrie::Persistence::ObjectNotFoundError] Raised when the alternate identifier
     #   isn't in the persistence backend.
@@ -73,9 +75,17 @@ module Valkyrie::Persistence::Memory
       end
     end
 
+    # Count all objects of a given model.
+    # @param model [Class] Class to query for.
+    # @return integer. Count objects in the persistence backend
+    #   with the given class.
+    def count_all_of_model(model:)
+      cache.values.select { |obj| obj.is_a?(model) }.count
+    end
+
     # Get all members of a given resource.
     # @param resource [Valkyrie::Resource] Model whose members are being searched for.
-    # @param model [Class] Class to query for. (optional)
+    # @param model [Class] Filter results to include only instances of this model. (optional)
     # @return [Array<Valkyrie::Resource>] child objects of type `model` referenced by
     #   `resource`'s `member_ids` method. Returned in order.
     def find_members(resource:, model: nil)
@@ -90,9 +100,10 @@ module Valkyrie::Persistence::Memory
     # @param resource [Valkyrie::Resource] Model whose property is being searched.
     # @param property [Symbol] Property which, on the `resource`, contains {Valkyrie::ID}s which are
     #   to be de-referenced.
+    # @param model [Class] Filter results to include only instances of this model. (optional)
     # @return [Array<Valkyrie::Resource>] All objects which are referenced by the
     #   `property` property on `resource`. Not necessarily in order.
-    def find_references_by(resource:, property:)
+    def find_references_by(resource:, property:, model: nil)
       refs = Array.wrap(resource[property]).map do |id|
         begin
           find_by(id: id)
@@ -101,25 +112,31 @@ module Valkyrie::Persistence::Memory
         end
       end.reject(&:nil?)
       refs.uniq! unless ordered_property?(resource: resource, property: property)
-      refs
+      return refs unless model
+      refs.select { |obj| obj.is_a?(model) }
     end
 
     # Get all resources which link to a resource with a given property.
     # @param resource [Valkyrie::Resource] The resource which is being referenced by
-    #   other resources.
+    #   other resources. Requires either resource or id parameter to be specified.
+    # @param id [Valkyrie::ID] ID of the resource which is being reference by other
+    #   resources. Requires either resource or id parameter to be specified.
     # @param property [Symbol] The property which, on other resources, is
     #   referencing the given `resource`
+    # @param model [Class] Filter results to include only instances of this model. (optional)
     # @raise [ArgumentError] Raised when the ID is not in the persistence backend.
     # @return [Array<Valkyrie::Resource>] All resources in the persistence backend
     #   which have the ID of the given `resource` in their `property` property. Not
     #   in order.
-    def find_inverse_references_by(resource: nil, id: nil, property:)
+    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
-      find_all.select do |obj|
+      result = find_all.select do |obj|
         Array.wrap(obj[property]).include?(id)
       end
+      return result unless model
+      result.select { |obj| obj.is_a?(model) }
     end
 
     # Find all parents of a given resource.
@@ -148,10 +165,15 @@ module Valkyrie::Persistence::Memory
         resource.member_ids || []
       end
 
+      # 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
 
+      # 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

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,6 +251,22 @@ module Valkyrie::Persistence::Postgres
 
     private
 
+      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
+
+      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
+
       # Determines whether or not an Object is a Valkyrie ID
       # @param [Object] id
       # @raise [ArgumentError]

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/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,51 +68,46 @@ 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]
+      # (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
+      # (see Valkyrie::Persistence::Memory::QueryService#ensure_persisted)
       def ensure_persisted(resource)
         raise ArgumentError, 'resource is not saved' unless resource.persisted?
       end
 
+      # (see Valkyrie::Persistence::Memory::QueryService#ordered_property?)
       def ordered_property?(resource:, property:)
         resource.ordered_attribute?(property)
       end