Run on elasticsearch

Author: jcoyne

.github/workflows/ruby.yml

@@ -41,9 +41,15 @@ jobs:
         bootstrap_version: [null]
         view_component_version: ["~> 3.12"]
         api: [null]
+        repository: [null]
         additional_engine_cart_rails_options: [""]
         additional_name: [""]
         include:
+          - ruby: "3.4"
+            rails_version: "8.0.1"
+            additional_engine_cart_rails_options: --css=bootstrap
+            repository: elasticsearch
+            additional_name: "/ elasticsearch"
           - ruby: "3.3"
             rails_version: "8.0.1"
             additional_engine_cart_rails_options: --css=bootstrap
@@ -76,6 +82,7 @@ jobs:
       VIEW_COMPONENT_VERSION: ${{ matrix.view_component_version }}
       BOOTSTRAP_VERSION: ${{ matrix.bootstrap_version }}
       BLACKLIGHT_API_TEST: ${{ matrix.api }}
+      BLACKLIGHT_REPOSITORY: ${{ matrix.repository }}
       ENGINE_CART_RAILS_OPTIONS: "--skip-git --skip-listen --skip-spring --skip-keeps --skip-kamal --skip-solid --skip-coffee --skip-test ${{ matrix.additional_engine_cart_rails_options }}"
     steps:
       - uses: actions/checkout@v4

app/services/blacklight/search_service.rb

@@ -118,35 +118,14 @@ def solr_opensearch_params(field)
       solr_params
     end
 
-    ##
-    # Pagination parameters for selecting the previous and next documents
-    # out of a result set.
-    def previous_and_next_document_params(index, window = 1)
-      solr_params = blacklight_config.document_pagination_params.dup
-
-      if solr_params.empty?
-        solr_params[:fl] = blacklight_config.document_model.unique_key
-      end
-
-      if index > 0
-        solr_params[:start] = index - window # get one before
-        solr_params[:rows] = (2 * window) + 1 # and one after
-      else
-        solr_params[:start] = 0 # there is no previous doc
-        solr_params[:rows] = 2 * window # but there should be one after
-      end
-
-      solr_params[:facet] = false
-      solr_params
-    end
+    delegate :previous_and_next_document_params, to: :search_builder
 
     ##
     # Retrieve a set of documents by id
     # @param [Array] ids
     # @param [HashWithIndifferentAccess] extra_controller_params
     def fetch_many(ids, extra_controller_params)
       extra_controller_params ||= {}
-
       query = search_builder
               .with(search_state)
               .where(blacklight_config.document_model.unique_key => ids)

blacklight.gemspec

@@ -35,6 +35,7 @@ Gem::Specification.new do |s|
   s.add_dependency "zeitwerk"
 
   s.add_development_dependency "rsolr", ">= 1.0.6", "< 3"  # Library for interacting with rSolr.
+  s.add_development_dependency "elasticsearch"
   s.add_development_dependency "rspec-rails", "~> 7.0"
   s.add_development_dependency "rspec-collection_matchers", ">= 1.0"
   s.add_development_dependency 'axe-core-rspec'

compose.yaml

@@ -36,3 +36,15 @@ services:
       - /opt/solr/conf
       - "-Xms256m"
       - "-Xmx512m"
+
+  elasticsearch:
+    environment:
+      - discovery.type=single-node
+      - xpack.security.enabled=false
+    image: elasticsearch:8.17.3
+    ports:
+      - 9200:9200
+    volumes:
+      - es_data:/usr/share/elasticsearch/data
+volumes:
+  es_data:

lib/blacklight.rb

@@ -27,11 +27,13 @@ def self.default_index=(repository)
   ##
   # The configured repository class. By convention, this is
   # the class Blacklight::(name of the adapter)::Repository, e.g.
-  #   elastic_search => Blacklight::ElasticSearch::Repository
+  #   elasticsearch => Blacklight::ElasticSearch::Repository
   def self.repository_class
     case connection_config[:adapter]
     when 'solr'
       Blacklight::Solr::Repository
+    when 'elasticsearch'
+      Blacklight::Elasticsearch::Repository
     when /::/
       connection_config[:adapter].constantize
     else

lib/blacklight/elasticsearch/repository.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Blacklight::Elasticsearch
+  class Repository < Blacklight::AbstractRepository
+    ##
+    # Find a single solr document result (by id) using the document configuration
+    # @param [String] id document's unique key value
+    # @param [Hash] params additional solr query parameters
+    def find id, params = {}
+      api_response = connection.get(index:, id:)
+      blacklight_config.response_model.new(api_response, params, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
+    rescue Elastic::Transport::Transport::Errors::NotFound
+      #      solr_response = blacklight_config.response_model.new(res, solr_params, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
+
+      # doc_params = params.reverse_merge(blacklight_config.default_document_solr_params)
+      #                    .reverse_merge(qt: blacklight_config.document_solr_request_handler)
+      #                    .merge(blacklight_config.document_unique_id_param => id)
+
+      # solr_response = send_and_receive blacklight_config.document_solr_path || blacklight_config.solr_path, doc_params
+      raise Blacklight::Exceptions::RecordNotFound
+    end
+
+    # Find multiple documents by their ids
+    # @param [Hash] _params query parameters
+    def find_many(search_builder)
+      # TODO: This is hacky, but SearchBuilder#where is currently very coupled to Solr
+      ids = search_builder.search_state.params['q']['id']
+      docs = ids.map { |id| { _index: index, _id: id } }
+
+      api_response = connection.mget(body: { docs: })
+      blacklight_config.response_model.new(api_response, search_builder, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
+    end
+
+    ##
+    # Execute a search query against solr
+    # @param [Hash] params solr query parameters
+    # @param [String] path solr request handler path
+    def search path: nil, params: nil, **kwargs
+      request_params = params.reverse_merge(kwargs)
+      api_response = connection.search(index:, body: request_params)
+      blacklight_config.response_model.new(api_response, params, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
+      # request_params = (params || pos_params).reverse_merge(kwargs).reverse_merge({ qt: blacklight_config.qt })
+
+      # send_and_receive(path || default_search_path(request_params), request_params)
+    end
+
+    def seed_index docs
+      body = docs.map { |data| { index: { _index: index, _id: data['id'], data: data.except('id') } } }
+      connection.bulk(body:)
+      connection.indices.refresh(index:)
+    end
+
+    def suggestions
+      []
+    end
+
+    private
+
+    def index
+      @index ||= connection_config.fetch(:index)
+    end
+
+    # See https://www.elastic.co/guide/en/elasticsearch/client/ruby-api/current/connecting.html
+    def build_connection
+      ::Elasticsearch::Client.new(url: connection_config[:url])
+      # cloud_id: '<CloudID>',
+      # user: '<Username>',
+      # password: '<Password>'
+    end
+  end
+end

lib/blacklight/elasticsearch/request.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# class Blacklight::Elasticsearch::InvalidParameter < ArgumentError; end
+
+class Blacklight::Elasticsearch::Request < ActiveSupport::HashWithIndifferentAccess
+  # This is similar to qf in Solr
+  cattr_accessor :query_fields, default: %w[ id
+                                             full_title_tsim
+                                             short_title_tsim
+                                             alternative_title_tsim
+                                             active_fedora_model_ssi
+                                             title_tsim
+                                             author_tsim
+                                             subject_tsim
+                                             all_text_timv]
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super
+    end
+  end
+
+  # See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-all-query.html
+  def match_all
+    must['match_all'] = {}
+  end
+
+  # https://www.elastic.co/guide/en/elasticsearch/reference/current/query-filter-context.html
+  def append_filter_query(filter_query)
+    bool['filter'] = filter_query
+  end
+
+  # See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-combined-fields-query.html
+  def append_query(query)
+    return if query.nil?
+
+    must['combined_fields'] = {
+      'query' => query,
+      'fields' => query_fields,
+      'operator' => 'or'
+    }
+  end
+
+  private
+
+  def bool
+    self['query'] ||= {}
+    self['query']['bool'] ||= {}
+  end
+
+  def must
+    bool['must'] ||= {}
+  end
+end

lib/blacklight/elasticsearch/response.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+class Blacklight::Elasticsearch::Response < ActiveSupport::HashWithIndifferentAccess
+  include Blacklight::Response::PaginationMethods
+
+  attr_reader :request_params, :search_builder
+  attr_accessor :blacklight_config, :options
+
+  delegate :document_factory, to: :blacklight_config
+
+  # @param [Elasticsearch::API::Response] response
+  def initialize(api_response, request_params, options = {})
+    @search_builder = request_params if request_params.is_a?(Blacklight::SearchBuilder)
+
+    super(ActiveSupport::HashWithIndifferentAccess.new(api_response))
+    @request_params = ActiveSupport::HashWithIndifferentAccess.new(request_params)
+    self.blacklight_config = options[:blacklight_config]
+    self.options = options
+  end
+
+  def total
+    hits[:total][:value]
+  end
+
+  def start
+    0
+  end
+
+  # def header
+  #   self['responseHeader'] || {}
+  # end
+
+  def documents
+    @documents ||= if self[:_source] # handle a get call
+                     [document_factory.build(self[:_source].merge(id: self[:_id]), self, options)]
+                   elsif self[:docs] # handle mget call
+                     self[:docs].collect { |doc| document_factory.build(doc[:_source].merge(id: doc[:_id]), self, options) }
+                   else # Search call
+                     dig(:hits, :hits).collect { |doc| document_factory.build(doc[:_source].merge(id: doc[:_id]), self, options) }
+                   end
+  end
+  alias docs documents
+
+  # def grouped
+  #   @groups ||= self["grouped"].map do |field, group|
+  #     # grouped responses can either be grouped by:
+  #     #   - field, where this key is the field name, and there will be a list
+  #     #        of documents grouped by field value, or:
+  #     #   - function, where the key is the function, and the documents will be
+  #     #        further grouped by function value, or:
+  #     #   - query, where the key is the query, and the matching documents will be
+  #     #        in the doclist on THIS object
+  #     if group["groups"] # field or function
+  #       GroupResponse.new field, group, self
+  #     else # query
+  #       Group.new field, group, self
+  #     end
+  #   end
+  # end
+
+  # def group key
+  #   grouped.find { |x| x.key == key }
+  # end
+
+  def aggregations
+    # @aggregations ||= default_aggregations.merge(facet_field_aggregations).merge(facet_query_aggregations).merge(facet_pivot_aggregations).merge(json_facet_aggregations)
+    {}
+  end
+
+  def grouped?
+    false
+  end
+
+  def spelling
+    nil
+  end
+
+  def more_like _document
+    []
+  end
+
+  # TODO: Same implementation as solr, move to mixin?
+  def export_formats
+    documents.map { |x| x.export_formats.keys }.flatten.uniq
+  end
+
+  def rows
+    search_builder&.rows || hits[:hits].length
+  end
+
+  private
+
+  def hits
+    self[:hits]
+  end
+end