blacklight 7.15.1 → 7.17.2

data/lib/blacklight/search_state.rb

@@ -115,9 +115,9 @@ module Blacklight
     # documents
     def url_for_document(doc, options = {})
       if respond_to?(:blacklight_config) &&
-          blacklight_config.show.route &&
+          blacklight_config.view_config(:show).route &&
           (!doc.respond_to?(:to_model) || doc.to_model.is_a?(SolrDocument))
-        route = blacklight_config.show.route.merge(action: :show, id: doc).merge(options)
+        route = blacklight_config.view_config(:show).route.merge(action: :show, id: doc).merge(options)
         route[:controller] = params[:controller] if route[:controller] == :current
         route
       else

data/lib/blacklight/solr/facet_paginator.rb

@@ -20,6 +20,8 @@ module Blacklight::Solr
     def initialize(all_facet_values, arguments = {})
       super
 
+      @sort = arguments[:sort].keys.first.to_s if arguments[:sort].is_a? Hash
+
       # count is solr's default
       @sort ||= if @limit.to_i > 0
                   'count'

data/lib/blacklight/solr/request.rb

@@ -17,6 +17,37 @@ class Blacklight::Solr::Request < ActiveSupport::HashWithIndifferentAccess
     end
   end
 
+  def append_query(query)
+    if self['q'] || dig(:json, :query, :bool)
+      self[:json] ||= { query: { bool: { must: [] } } }
+      self[:json][:query] ||= { bool: { must: [] } }
+      self[:json][:query][:bool][:must] << query
+
+      if self['q']
+        self[:json][:query][:bool][:must] << self['q']
+        delete 'q'
+      end
+    else
+      self['q'] = query
+    end
+  end
+
+  def append_boolean_query(bool_operator, query)
+    return if query.blank?
+
+    self[:json] ||= { query: { bool: { bool_operator => [] } } }
+    self[:json][:query] ||= { bool: { bool_operator => [] } }
+    self[:json][:query][:bool][bool_operator] ||= []
+
+    if self['q']
+      self[:json][:query][:bool][:must] ||= []
+      self[:json][:query][:bool][:must] << self['q']
+      delete 'q'
+    end
+
+    self[:json][:query][:bool][bool_operator] << query
+  end
+
   def append_filter_query(query)
     self['fq'] << query
   end

data/lib/blacklight/solr/response.rb

@@ -9,6 +9,7 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
     autoload :MoreLikeThis
     autoload :GroupResponse
     autoload :Group
+    autoload :Params
   end
 
   include PaginationMethods
@@ -16,6 +17,7 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
   include Facets
   include Response
   include MoreLikeThis
+  include Params
 
   attr_reader :request_params
   attr_accessor :blacklight_config, :options
@@ -33,22 +35,6 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
     self['responseHeader'] || {}
   end
 
-  def params
-    header['params'] || request_params
-  end
-
-  def start
-    params[:start].to_i
-  end
-
-  def rows
-    params[:rows].to_i
-  end
-
-  def sort
-    params[:sort]
-  end
-
   def documents
     @documents ||= (response['docs'] || []).collect { |doc| document_factory.build(doc, self, options) }
   end

data/lib/blacklight/solr/response/facets.rb

@@ -29,6 +29,7 @@ module Blacklight::Solr::Response::Facets
   # represents a facet; which is a field and its values
   class FacetField
     attr_reader :name, :items
+    attr_accessor :missing
 
     def initialize name, items, options = {}
       @name = name
@@ -52,6 +53,14 @@ module Blacklight::Solr::Response::Facets
       @options[:prefix] || solr_default_prefix
     end
 
+    def type
+      @options[:type] || 'terms'
+    end
+
+    def data
+      @options[:data] || {}
+    end
+
     def index?
       sort == 'index'
     end
@@ -90,7 +99,7 @@ module Blacklight::Solr::Response::Facets
   # Get all the Solr facet data (fields, queries, pivots) as a hash keyed by
   # both the Solr field name and/or by the blacklight field name
   def aggregations
-    @aggregations ||= {}.merge(facet_field_aggregations).merge(facet_query_aggregations).merge(facet_pivot_aggregations)
+    @aggregations ||= {}.merge(facet_field_aggregations).merge(facet_query_aggregations).merge(facet_pivot_aggregations).merge(json_facet_aggregations)
   end
 
   def facet_counts
@@ -159,19 +168,24 @@ module Blacklight::Solr::Response::Facets
       items = values.map do |value, hits|
         i = FacetItem.new(value: value, hits: hits)
 
-        # solr facet.missing serialization
+        # legacy solr facet.missing serialization
         if value.nil?
           i.label = I18n.t(:"blacklight.search.fields.facet.missing.#{facet_field_name}", default: [:"blacklight.search.facets.missing"])
           i.fq = "-#{facet_field_name}:[* TO *]"
+          i.missing = true
         end
 
         i
       end
 
       options = facet_field_aggregation_options(facet_field_name)
-      hash[facet_field_name] = FacetField.new(facet_field_name,
-                                              items,
-                                              options)
+      facet_field = FacetField.new(facet_field_name, items, options)
+
+      if values[nil]
+        facet_field.missing = items.find(&:missing)
+      end
+
+      hash[facet_field_name] = facet_field
 
       # alias all the possible blacklight config names..
       blacklight_config.facet_fields.select { |_k, v| v.field == facet_field_name }.each_key do |key|
@@ -180,23 +194,6 @@ module Blacklight::Solr::Response::Facets
     end
   end
 
-  def facet_field_aggregation_options(facet_field_name)
-    options = {}
-    options[:sort] = (params[:"f.#{facet_field_name}.facet.sort"] || params[:'facet.sort'])
-    if params[:"f.#{facet_field_name}.facet.limit"] || params[:"facet.limit"]
-      options[:limit] = (params[:"f.#{facet_field_name}.facet.limit"] || params[:"facet.limit"]).to_i
-    end
-
-    if params[:"f.#{facet_field_name}.facet.offset"] || params[:'facet.offset']
-      options[:offset] = (params[:"f.#{facet_field_name}.facet.offset"] || params[:'facet.offset']).to_i
-    end
-
-    if params[:"f.#{facet_field_name}.facet.prefix"] || params[:'facet.prefix']
-      options[:prefix] = (params[:"f.#{facet_field_name}.facet.prefix"] || params[:'facet.prefix'])
-    end
-    options
-  end
-
   ##
   # Aggregate Solr's facet_query response into the virtual facet fields defined
   # in the blacklight configuration
@@ -211,12 +208,28 @@ module Blacklight::Solr::Response::Facets
         Blacklight::Solr::Response::Facets::FacetItem.new(value: key, hits: hits, label: facet_field.query[key][:label])
       end
 
+      items += facet_query_aggregations_from_json(facet_field)
+
       items = items.sort_by(&:hits).reverse if facet_field.sort && facet_field.sort.to_sym == :count
 
       hash[field_name] = Blacklight::Solr::Response::Facets::FacetField.new field_name, items
     end
   end
 
+  def facet_query_aggregations_from_json(facet_field)
+    return [] unless self['facets']
+
+    salient_facet_queries = facet_field.query.map { |_k, x| x[:fq] }
+
+    relevant_facet_data = self['facets'].select { |k, _v| salient_facet_queries.include?(k) }.reject { |_key, data| data['count'].zero? }
+
+    relevant_facet_data.map do |key, data|
+      salient_fields = facet_field.query.select { |_key, val| val[:fq] == key }
+      facet_key = ((salient_fields.keys if salient_fields.respond_to? :keys) || salient_fields.first).first
+      Blacklight::Solr::Response::Facets::FacetItem.new(value: facet_key, hits: data[:count], label: facet_field.query[facet_key][:label])
+    end
+  end
+
   ##
   # Convert Solr's facet_pivot response into
   # a hash of Blacklight::Solr::Response::Facet::FacetField objects
@@ -244,4 +257,45 @@ module Blacklight::Solr::Response::Facets
 
     Blacklight::Solr::Response::Facets::FacetItem.new(value: lst[:value], hits: lst[:count], field: lst[:field], items: items, fq: parent_fq)
   end
+
+  def construct_json_nested_facet_fields(bucket, parent_fq = {})
+    bucket.select { |_, nested| nested.is_a?(Hash) && nested.key?('buckets') }.map do |facet_field_name, nested|
+      nested['buckets'].map do |subbucket|
+        i = Blacklight::Solr::Response::Facets::FacetItem.new(field: facet_field_name, value: subbucket['val'], hits: subbucket['count'], fq: parent_fq, data: subbucket)
+
+        i.items = construct_json_nested_facet_fields(subbucket, parent_fq.merge(key => subbucket['val'])) if has_json_nested_facets?(subbucket)
+        i
+      end
+    end.flatten
+  end
+
+  def has_json_nested_facets?(bucket)
+    bucket.any? { |_, nested| nested.is_a?(Hash) && nested.key?('buckets') }
+  end
+
+  def json_facet_aggregations
+    return {} unless self['facets']
+
+    self['facets'].each_with_object({}) do |(facet_field_name, data), hash|
+      next if facet_field_name == 'count'
+
+      items = (data['buckets'] || []).map do |bucket|
+        i = Blacklight::Solr::Response::Facets::FacetItem.new(value: bucket['val'], hits: bucket['count'], data: bucket)
+
+        i.items = construct_json_nested_facet_fields(bucket, facet_field_name => bucket['val']) if has_json_nested_facets?(bucket)
+
+        i
+      end
+
+      options = facet_field_aggregation_options(facet_field_name).merge(data: data)
+      facet_field = FacetField.new(facet_field_name, items, options)
+
+      facet_field.missing = Blacklight::Solr::Response::Facets::FacetItem.new(
+        hits: data.dig('missing', 'count'),
+        data: data['missing']
+      ) if data['missing']
+
+      hash[facet_field_name] = facet_field
+    end
+  end
 end

data/lib/blacklight/solr/response/params.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+module Blacklight::Solr::Response::Params
+  # From https://solr.apache.org/guide/8_8/json-request-api.html#supported-properties-and-syntax
+  QUERY_PARAMETER_TO_JSON_PARAMETER_MAPPING = {
+    q: :query,
+    fq: :filter,
+    start: :offset,
+    rows: :limit,
+    fl: :fields,
+    sort: :sort
+  }.freeze
+
+  def params
+    header['params'] || request_params
+  end
+
+  def start
+    search_builder&.start || single_valued_param(:start).to_i
+  end
+
+  def rows
+    search_builder&.rows || single_valued_param(:rows).to_i
+  end
+
+  def sort
+    search_builder&.sort || single_valued_param(:sort)
+  end
+
+  def facet_field_aggregation_options(facet_field_name)
+    defaults = {
+      sort: single_valued_param(:'facet.sort'),
+      limit: single_valued_param(:"facet.limit")&.to_i || 100,
+      offset: single_valued_param(:"facet.offset")&.to_i || 0,
+      prefix: single_valued_param(:"facet.prefix")
+    }
+
+    json_facet = json_params.dig('facet', facet_field_name)&.slice(:limit, :offset, :prefix, :sort)&.symbolize_keys || {}
+
+    param_facet = {
+      sort: single_valued_param(:"f.#{facet_field_name}.facet.sort"),
+      limit: single_valued_param(:"f.#{facet_field_name}.facet.limit")&.to_i,
+      offset: single_valued_param(:"f.#{facet_field_name}.facet.offset")&.to_i,
+      prefix: single_valued_param(:"f.#{facet_field_name}.facet.prefix")
+    }.reject { |_k, v| v.nil? }
+
+    options = defaults.merge(json_facet).merge(param_facet)
+    options[:sort] ||= options[:limit].positive? ? 'count' : 'index'
+
+    options
+  end
+
+  private
+
+  def search_builder
+    request_params if request_params.is_a?(Blacklight::SearchBuilder)
+  end
+
+  # Extract JSON Request API parameters from the response header or the request itself
+  def json_params
+    encoded_json_params = header&.dig('params', 'json')
+
+    return request_params['json'] || {} if encoded_json_params.blank?
+
+    @json_params ||= JSON.parse(encoded_json_params).with_indifferent_access
+  end
+
+  # Handle merging solr parameters from the myriad of ways they may be expressed by applying the single-value
+  # precedence logic:
+  #
+  # From https://solr.apache.org/guide/8_8/json-request-api.html#json-parameter-merging :
+  # When multiple parameter values conflict with one another a single value is chosen based on the following precedence rules:
+  # - Traditional query parameters (q, rows, etc.) take first precedence and are used over any other specified values.
+  # - json-prefixed query parameters are considered next.
+  # - Values specified in the JSON request body have the lowest precedence and are only used if specified nowhere else.
+  #
+  # @param [String] key the solr parameter to use
+  def single_valued_param(key)
+    json_key = QUERY_PARAMETER_TO_JSON_PARAMETER_MAPPING[key]
+
+    params[key] ||
+      params["json.#{key}"] ||
+      json_params[json_key || key] ||
+      json_params.dig(:params, key) ||
+      json_params.dig(:params, "json.#{key}")
+  end
+
+  # Merge together multi-valued solr parameters from the myriad of ways they may be expressed.
+  # Unlike single-valued parameters, this merges all the values across the params.
+  #
+  # @param [String] key the solr parameter to use
+  def multivalued_param(key)
+    json_key = QUERY_PARAMETER_TO_JSON_PARAMETER_MAPPING[key]
+
+    [
+      params[key],
+      params["json.#{key}"],
+      json_params[json_key || key],
+      json_params.dig(:params, key),
+      json_params.dig(:params, "json.#{key}")
+    ].select(&:present?).inject([]) do |memo, arr|
+      memo.concat(Array.wrap(arr))
+    end
+  end
+end

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -59,12 +59,14 @@ module Blacklight::Solr
       ##
       if search_field&.query_builder.present?
         add_search_field_query_builder_params(solr_parameters)
+      elsif search_field&.clause_params.present?
+        add_search_field_with_json_query_parameters(solr_parameters)
       elsif search_field&.solr_local_parameters.present?
         add_search_field_with_local_parameters(solr_parameters)
       elsif search_state.query_param.is_a? Hash
         add_additional_filters(solr_parameters, search_state.query_param)
       elsif search_state.query_param
-        solr_parameters[:q] = search_state.query_param
+        solr_parameters.append_query search_state.query_param
       end
     end
 
@@ -73,39 +75,41 @@ module Blacklight::Solr
 
       return if q.blank?
 
-      solr_parameters[:q] = if q.values.any?(&:blank?)
-                              # if any field parameters are empty, exclude _all_ results
-                              "{!lucene}NOT *:*"
-                            else
-                              "{!lucene}" + q.map do |field, values|
-                                "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
-                              end.join(" AND ")
-                            end
+      if q.values.any?(&:blank?)
+        # if any field parameters are empty, exclude _all_ results
+        solr_parameters.append_query "{!lucene}NOT *:*"
+      else
+        composed_query = q.map do |field, values|
+          "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
+        end.join(" AND ")
+
+        solr_parameters.append_query "{!lucene}#{composed_query}"
+      end
 
       solr_parameters[:defType] = 'lucene'
       solr_parameters[:spellcheck] = 'false'
     end
 
+    def add_search_field_with_json_query_parameters(solr_parameters)
+      bool_query = search_field.clause_params.transform_values { |v| v.merge(query: search_state.query_param) }
+
+      solr_parameters.append_boolean_query(:must, bool_query)
+    end
+
     # Transform "clause" parameters into the Solr JSON Query DSL
     def add_adv_search_clauses(solr_parameters)
       return if search_state.clause_params.blank?
 
       defaults = { must: [], must_not: [], should: [] }
-      bool_query = (solr_parameters.dig(:json, :query, :bool) || {}).reverse_merge(defaults)
-
       default_op = blacklight_params[:op]&.to_sym || :must
+      solr_parameters[:mm] = 1 if default_op == :should && search_state.clause_params.values.any? { |clause| }
 
       search_state.clause_params.each_value do |clause|
         op, query = adv_search_clause(clause, default_op)
-        bool_query[op] << query if defaults.key?(op) && query
-      end
-
-      return if bool_query.values.all?(&:blank?)
+        next unless defaults.key?(op)
 
-      solr_parameters[:mm] = 1 if default_op == :should
-      solr_parameters[:json] ||= { query: { bool: {} } }
-      solr_parameters[:json][:query] ||= { bool: {} }
-      solr_parameters[:json][:query][:bool] = bool_query.reject { |_k, v| v.blank? }
+        solr_parameters.append_boolean_query(op, query)
+      end
     end
 
     # @return [Array] the first element is the query operator and the second is the value to add
@@ -131,7 +135,7 @@ module Blacklight::Solr
         if filter.config.filter_query_builder
           filter_query, subqueries = filter.config.filter_query_builder.call(self, filter, solr_parameters)
 
-          solr_parameters.append_filter_query(filter_query)
+          solr_parameters.append_filter_query(filter_query) if filter_query
           solr_parameters.merge!(subqueries) if subqueries
         else
           filter.values.reject(&:blank?).each do |value|
@@ -148,6 +152,21 @@ module Blacklight::Solr
       end
     end
 
+    def add_solr_facet_json_params(solr_parameters, field_name, facet, **additional_parameters)
+      solr_parameters[:json] ||= { facet: {} }
+      solr_parameters[:json][:facet] ||= {}
+
+      field_config = facet.json.respond_to?(:reverse_merge) ? facet.json : {}
+
+      field_config = field_config.reverse_merge(
+        type: 'terms',
+        field: facet.field,
+        limit: facet_limit_with_pagination(field_name)
+      ).merge(additional_parameters)
+
+      solr_parameters[:json][:facet][field_name] = field_config.select { |_k, v| v.present? }
+    end
+
     ##
     # Add appropriate Solr facetting directives in, including
     # taking account of our facet paging/'more'.  This is not
@@ -156,6 +175,11 @@ module Blacklight::Solr
       facet_fields_to_include_in_request.each do |field_name, facet|
         solr_parameters[:facet] ||= true
 
+        if facet.json
+          add_solr_facet_json_params(solr_parameters, field_name, facet)
+          next
+        end
+
         if facet.pivot
           solr_parameters.append_facet_pivot with_ex_local_param(facet.ex, facet.pivot.join(","))
         elsif facet.query
@@ -225,9 +249,7 @@ module Blacklight::Solr
 
       facet_config = blacklight_config.facet_fields[facet]
 
-      # Now override with our specific things for fetching facet values
-      facet_ex = facet_config.respond_to?(:ex) ? facet_config.ex : nil
-      solr_params[:"facet.field"] = with_ex_local_param(facet_ex, facet_config.field)
+      solr_params[:rows] = 0
 
       limit = if solr_params["facet.limit"]
                 solr_params["facet.limit"].to_i
@@ -240,13 +262,21 @@ module Blacklight::Solr
       prefix = search_state.facet_prefix
       offset = (page - 1) * limit
 
+      if facet_config.json
+        add_solr_facet_json_params(solr_parameters, facet, facet_config, limit: limit + 1, offset: offset, sort: sort, prefix: prefix)
+        return
+      end
+
+      # Now override with our specific things for fetching facet values
+      facet_ex = facet_config.respond_to?(:ex) ? facet_config.ex : nil
+      solr_params[:"facet.field"] = with_ex_local_param(facet_ex, facet_config.field)
+
       # Need to set as f.facet_field.facet.* to make sure we
       # override any field-specific default in the solr request handler.
       solr_params[:"f.#{facet_config.field}.facet.limit"] = limit + 1
       solr_params[:"f.#{facet_config.field}.facet.offset"] = offset
       solr_params[:"f.#{facet_config.field}.facet.sort"] = sort if sort
       solr_params[:"f.#{facet_config.field}.facet.prefix"] = prefix if prefix
-      solr_params[:rows] = 0
     end
 
     def with_ex_local_param(ex, value)
@@ -367,7 +397,7 @@ module Blacklight::Solr
     ##
     # The key to use to retrieve the grouped field to display
     def grouped_key_for_results
-      blacklight_config.index.group
+      blacklight_config.view_config(action_name: :index).group
     end
 
     def facet_fields_to_include_in_request
@@ -385,7 +415,7 @@ module Blacklight::Solr
     def add_search_field_query_builder_params(solr_parameters)
       q, additional_parameters = search_field.query_builder.call(self, search_field, solr_parameters)
 
-      solr_parameters[:q] = q
+      solr_parameters.append_query q
       solr_parameters.merge!(additional_parameters) if additional_parameters
     end
 
@@ -393,7 +423,7 @@ module Blacklight::Solr
       local_params = search_field.solr_local_parameters.map do |key, val|
         key.to_s + "=" + solr_param_quote(val, quote: "'")
       end.join(" ")
-      solr_parameters[:q] = "{!#{local_params}}#{search_state.query_param}"
+      solr_parameters.append_query "{!#{local_params}}#{search_state.query_param}"
 
       ##
       # Set Solr spellcheck.q to be original user-entered query, without