has_helpers 5.0.2

data/app/lib/has_helpers/index.rb

@@ -0,0 +1,890 @@
+# frozen_string_literal: true
+
+module HasHelpers::Index
+  class HasHelpers::Index::Error < StandardError; end
+
+  MAX_NGRAM_SIZE = 20 # TODO Try to reduce this
+  MIN_NGRAM_SIZE = 1
+  MAX_NGRAM_DIFF = MAX_NGRAM_SIZE - MIN_NGRAM_SIZE
+
+  def self.search(query, indexes:, where: {}, routing: nil, show_inactive: nil, **options)
+    unless where[:organization_id].present? || !routing.nil?
+      raise HasHelpers::Index::Error, <<-MSG.squish
+        `organization_id` is required inside the `where` option
+        unless `routing` is specified. Add `routing: false` to search
+        across all organizations.
+      MSG
+    end
+
+    organization_id = where[:organization_id]
+    indexes = Array(indexes)
+    weighted_attrs = indexes.map(&:weighted_attr).uniq
+    weighted_attr = weighted_attrs.length == 1 ? weighted_attrs.first : "updated_at"
+
+    where = where.except(:organization_id)
+    where[:_and] ||= []
+    where[:_and] << {
+      _or: [
+        { organization_id: organization_id },
+        { organization_id: nil }
+      ]
+    }
+
+    unless show_inactive || indexes.any?(&:show_end_dated_records?)
+      [
+        { is_inactive: nil },
+        {
+          _or: [
+            { start_date: nil },
+            { start_date: { lte: ::Date.today } }
+          ]
+        },
+        {
+          _or: [
+            { end_date: nil },
+            { end_date: { gte: ::Date.today } }
+          ]
+        }
+      ].each { |default_filter| where[:_and] << default_filter }
+    end
+
+    routing_key =
+      if routing == false
+        nil
+      else
+        default_routing_key =
+          if indexes.any?(&:is_global?)
+            [0, organization_id]
+          else
+            organization_id
+          end
+
+        routing || default_routing_key
+      end
+
+    organization = ::HasHelpers::Organization.find_by(id: organization_id)
+    use_keyword_query = organization && ::HasHelpers::Feature.active?(:keyword_search, organization) && is_keyword_query?(query, indexes)
+    index_name = use_keyword_query ? indexes.map(&:keyword_search_index_name) : indexes.map(&:index_name)
+    Searchkick.search(
+      query,
+      index_name: index_name.size > 1 ? index_name.select { |index| active_indices.include? index } : index_name, # only use available indexes for gloabl search
+      fields: use_keyword_query ? nil : [:all_fields],
+      load: false,
+      misspellings: false,
+      routing: routing_key,
+      where: where,
+      **options
+    ) do |body|
+      q = body[:query]
+
+      q[:bool][:must][:bool][:should][0][:dis_max][:queries].tap do |queries|
+        if use_keyword_query
+          queries.clear
+          keyword_query_array = []
+          keyword_queries = parse_keyword_query(query, indexes)
+          keyword_queries.each do |field_name, search_text|
+            keyword_query_array << {
+              match: {
+                field_name => {
+                  query: search_text,
+                  boost: 20,
+                  operator: "and",
+                  analyzer: "classic_search"
+                }
+              }
+            }
+          end
+          queries << { bool: { must: keyword_query_array } }
+        else
+          # Weight name matches higher
+          if organization && ::HasHelpers::Feature.active?(:classic_name_search, organization)
+            queries << {
+              match: {
+                "name.analyzed" => {
+                  query: query,
+                  boost: 25,
+                  operator: "and",
+                  analyzer: "classic_search"
+                }
+              }
+            }
+          else
+            queries << {
+              match: {
+                "name.analyzed" => {
+                  query: query,
+                  boost: 25,
+                  operator: "and",
+                  analyzer: "searchkick_search"
+                }
+              }
+            }
+          end
+
+          # Tokens matched using the classic search should be weighted between our searchkick queries (10)
+          # and the name query (25). Classic search is useful for searching emails or acronyms.
+          queries << {
+            match: {
+              "all_fields.analyzed" => {
+                query: query,
+                boost: 20,
+                operator: "and",
+                analyzer: "classic_search"
+              }
+            }
+          }
+
+          # Also search keywords with the classic search.
+          # The analyzed field uses tokens filtered by nGrams which can make
+          # it so that results aren't found if the query is tokenized into
+          # tokens greater than the max ngram length
+          if query.length > MAX_NGRAM_SIZE
+            queries << {
+              match: {
+                "all_fields.keyword" => {
+                  query: query,
+                  boost: 20,
+                  operator: "and",
+                  analyzer: "classic_search"
+                }
+              }
+            }
+          end
+        end
+
+        # Use exact search if query contains double quotes
+        if query.count('"') > 1
+          q[:bool][:must] = [q[:bool][:must]]
+          q[:bool][:must] << {
+            match: {
+              "all_fields.keyword" => {
+                query: query,
+                operator: "and",
+                analyzer: "keyword_search"
+              }
+            }
+          }
+        end
+      end
+
+      # Weight recently viewed/updated records higher
+      body[:query] = {
+        function_score: {
+          score_mode: "sum",
+          boost_mode: "multiply",
+          functions: [{ weight: 1 }, { weight: 5, gauss: { "#{weighted_attr}": { scale: "365d", decay: 0.5 } } }],
+          query: q
+        }
+      }
+    end
+  end
+
+  def self.included(mod)
+    @indices ||= Set.new
+    @indices.add(mod)
+    mod.extend(ClassMethods)
+    mod.send(:configure)
+  end
+
+  # indexes only one big resource at a time
+  def self.scheduled_reindexing
+    all_index_names = ::HasHelpers::Index.indices.to_a.map(&:name)
+    all_index_names.each do |index_name|
+      ElasticsearchReindexScheduler.perform_async(index_name)
+    end
+  end
+
+  # HasHelpers::Index.indices
+  def self.indices
+    @indices
+  end
+
+  # Returns all indices that are in use. It does this
+  # by checking if they have an alias.
+  def self.active_indices
+    Searchkick.client.indices.get_alias.map { |_name, options| options["aliases"].keys }.flatten.compact
+  end
+
+  def self.config
+    ::HasHelpers.config.index
+  end
+
+  def self.after_index(key)
+    config.after_index.call(key)
+  end
+
+  def self.before_index(klass)
+    config.before_index.call(klass)
+  end
+
+  def self.filter_hidden_constants(results, organization_id)
+    config.filter_hidden_constants.call(results, organization_id)
+  end
+
+  # Sets default attributes to add to every index records.
+  # ==Example
+  # HasHelpers::Index.default_attributes do
+  #   {
+  #     is_inactive: false,
+  #     indexed_at: Time.now
+  #   }
+  # end
+  def self.default_attributes(&block)
+    if block.present?
+      @default_attributes = block.call
+    else
+      @default_attributes || { is_inactive: nil }
+    end
+  end
+
+  def self.parse_keyword_query(query_string, indexes = indices)
+    queries = {}
+    columns_to_search = indexes.map(&:columns_to_search).flatten.uniq
+    separated_query_string = query_string.downcase.split(/(?:\s+(?=\S+:))/).reject(&:empty?).map(&:rstrip)
+    separated_query_string.each do |single_query|
+      if /^(?<query_field>\w+):\s*(?<query_term>.+)\s*/ =~ single_query
+        field_name = query_term.length > MAX_NGRAM_SIZE ? "keyword" : "wildcard_index"
+        queries["#{query_field}.#{field_name}"] = query_term if columns_to_search.include?(query_field.to_sym)
+      end
+    end
+    queries
+  end
+
+  def self.is_keyword_query?(query_string, indexes = indices)
+    query_string.include?(":") &&
+      indexes.each do |idx|
+        return true if /#{idx.keyword_search_field_regex}/.match?(query_string)
+      end
+    false
+  end
+
+  module ClassMethods
+    EXCLUDED_SEARCH_TYPES = [:date, :datetime, :uuid]
+
+    def weighted_attr(attr_name = :updated_at)
+      @weighted_attr ||= attr_name
+    end
+
+    def is_heavy_index(value = false)
+      @is_heavy_index ||= value
+    end
+
+    def search(query, **options)
+      HasHelpers::Index.search(query, indexes: [self], **options)
+    end
+
+    def refresh
+      client.indices.refresh index: index_name
+      client.indices.refresh index: keyword_search_index_name
+    end
+
+    def reindex
+      ::ActiveRecord::Base.connection.execute <<-SQL
+        DROP VIEW IF EXISTS #{view_name};
+        CREATE VIEW #{view_name} AS #{self.sql};
+      SQL
+      clean
+      new_name = "#{index_name}_#{Time.zone.now.strftime('%Y%m%d%H%M%S%L')}"
+      new_keyword_index_name = "#{keyword_search_index_name}_#{Time.zone.now.strftime('%Y%m%d%H%M%S%L')}"
+      # Create the new index, with refresh turned off for faster reindexing.
+      create(new_name, settings.deep_merge!(settings: { index: { refresh_interval: -1 } }))
+      create(new_keyword_index_name, keyword_index_settings.deep_merge!(settings: { index: { refresh_interval: -1 } }))
+      client.indices.put_settings(body: { index: { blocks: { read_only_allow_delete: false } } })
+      ElasticsearchReindex.perform_async(self.name, new_name)
+      ElasticsearchReindex.perform_async(self.name, new_keyword_index_name)
+      "#{new_name} #{new_keyword_index_name}"
+    end
+
+    def reindex_queue
+      ::HasHelpers::ReindexQueue.new(index_name)
+    end
+
+    def keyword_reindex_queue
+      ::HasHelpers::ReindexQueue.new(keyword_search_index_name)
+    end
+
+    def model
+      @model ||= name.remove("Index").constantize
+    end
+
+    # Specifies what other models should trigger a reindex, as well as the conditions for triggering one.
+    #  The <b>to</b> attribute the key to search against the from set. <b>id</b> by default.
+    #  The <b>from</b> attribute to get the object from. By default <b>model.name.foreign_key e.g. advisor_id</b> or <b>id</b> if dependency_inheritance is present.
+    #  The <b>dependent_attributes</b> attribute is a list of the attributes that has to be changed to make a reindex
+    #  The <b>dependency_inheritance</b> attribute is a inheritance list of lists declaring the paths to get to the resource.
+    #
+    # Example usage (using ::AdvisorIndex as the example index):
+    #
+    #   depends_on(::Contract)
+    #   This will make it so that any change to a contract that has an advisor_id will cause the advisor to be reindexed.
+    #
+    #   depends_on("Contract": { dependent_attributes: %w(writing_number advisor_id) })
+    #   This will make it so that the advisor is reindexed only when the contract's writing number or advisor id is updated.
+    #
+    # Example usage (using ::ContractIndex as the example index):
+    #
+    #   depends_on("ContractLevel": { dependent_attributes: %w(product_type_id) })
+    #   This will make it so that the ContractIndex is reindexed only when the contract level's product_type_id is updated.
+    #
+    #   depends_on("Carrier": { dependent_attributes: %w(name),
+    #           dependency_inheritance:  [
+    #             <tt>[</tt> { target: "Contract", to: "carrier_id" } <tt>]</tt>
+    #           ]
+    #   })
+    #   As the Carrier has an indirect reference to a contract we have to set the inheritance to get to it.
+    #   This will update the ContractIndex only when the carrier's name is updated through the path defined on the
+    #   dependency_inheritance array. In this case this contract will be updated:
+    #   Contract.where( carrier_id: "UPDATED_CARRIER_ID" )
+    #
+    #   depends_on("HasContactInfo::Demographic": { dependent_attributes: %w(nickname ssn),
+    #          dependency_inheritance:  [
+    #            [ { target: "Advisor", to: "demographic_id" },
+    #              { target: "Contract", to: "advisor_id" }
+    #            ]
+    #         ]
+    #     })
+    #  This will make it so that the Contract is reindex only when (following the inheritance) the Contract's Advisor's
+    #  nicknamme or ssn are updated
+    #
+    #  depends_on("Firm": { from: "id", dependent_attributes: %w(name taxid),
+    #          dependency_inheritance:  [
+    #            <tt>[</tt>{ target: "Contract", to: "corporate_id" }<tt>]</tt> ,
+    #            <tt>[</tt>{ target: "Contract", to: "broker_dealer_id" }<tt>]</tt>,
+    #            <tt>[</tt>{ target: "Contract", to: "firm_id" }<tt>]</tt>
+    #          ]
+    #     })
+    #  In this case we have 3 lists inside the dependency_inheritance list. Each will be independet of each other.
+    #  This will make it so that the Contract is reindexed ony when:
+    #     1. The Contract's corporate name or taxid are updated
+    #     2. The Contract's broker_dealer name or taxid are updated
+    #     3. The Contract's firm name or taxid gets updated
+    #
+    def depends_on(*klasses, **klasses_with_keys)
+      @depends_on ||= [].tap do |dependency_array|
+        klasses.each do |dependency_klass|
+          klass = dependency_klass.to_s.safe_constantize
+          dependency_array << add_dependency(klass: klass)
+        end
+        klasses_with_keys.each do |klass_name, keys|
+          dependency_array << add_dependency(
+            klass: klass_name.to_s.safe_constantize,
+            from_key: keys[:from], to_key: keys[:to],
+            dependent_attributes: keys[:dependent_attributes],
+            dependency_inheritance: keys[:dependency_inheritance])
+        end
+      end
+    end
+
+    # Deletes all the indices that are not currently in use. It does this
+    # by checking if they have an alias.
+    def clean
+      indices_to_delete = old_indices
+
+      # If clean occurs during a reindex, and it runs in the time between
+      # when the new index is created and when it's assigned an alias, then
+      # it's possible that it will delete the newly created index which would
+      # cause reindexing to fail. We need to make sure that the most recent
+      # index is not affected by cleaning.
+      keyword_indices = indices.keys.select { |idx_name| idx_name.include?("keyword") }
+      non_keyword_indices = indices.keys - keyword_indices
+      most_recent_keyword_index_name = keyword_indices.sort.last
+      most_recent_index_name = non_keyword_indices.sort.last
+      [most_recent_index_name, most_recent_keyword_index_name].each do |most_recent_name|
+        if most_recent_name&.match?(/20\d{15}/) # If the most recent index doesn't have a timestamp, it should probably be deleted anyway.
+          indices_to_delete = indices_to_delete.reject do |non_aliased_index_name, _|
+            non_aliased_index_name == most_recent_name
+          end
+        end
+      end
+
+      indices_to_delete.each { |name, _options| delete(name) }
+    end
+
+    def clean!
+      raise Error, "clean! should only be used for testing" unless ::HasUtils::Env.test?
+
+      refresh
+      all_deletes = [index_name, keyword_search_index_name].map do |idx_name|
+        results = client.search(index: idx_name, body: { query: { match_all: {} } })
+        results.fetch("hits", {}).fetch("hits", []).map do |result|
+          {
+            delete: {
+              routing: result["_routing"],
+              _index: idx_name,
+              _id: result["_id"],
+              _type: result["_type"]
+            }
+          }
+        end
+      end
+      Searchkick.indexer.queue(all_deletes.flatten)
+      refresh
+    end
+
+    def indices
+      regex = /\A#{Regexp.escape(index_name)}/
+      keyword_regex = /\A#{Regexp.escape("keyword_" + index_name)}/
+      client.indices.get_alias.select { |name, _options| name.match?(regex) || name.match?(keyword_regex) }
+    rescue Elasticsearch::Transport::Transport::Errors::NotFound
+      {}
+    end
+
+    # Returns all indices without an alias.
+    # PolicyIndex.old_indices
+    def old_indices
+      indices.select { |_name, options| options["aliases"].blank? }
+    end
+
+    # Promotes an index for searching.
+    def promote(index)
+      index_alias = index.include?("keyword") ? keyword_search_index_name : index_name
+      old_indices =
+        begin
+          client.indices.get_alias(name: index_alias).keys
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          {}
+        end
+      actions = old_indices.map { |old_name| { remove: { index: old_name, alias: index_alias } } } + [{ add: { index: index, alias: index_alias } }]
+      client.indices.update_aliases body: { actions: actions }
+    end
+
+    def update_settings(index, settings)
+      client.indices.put_settings index: index, body: settings
+    end
+
+    def get_settings(index)
+      client.indices.get_settings index: index
+    rescue Elasticsearch::Transport::Transport::Errors::NotFound
+      # not found
+      {}
+    end
+
+    def heavy_indices
+      ::HasHelpers::Index.indices.to_a.select { |index| index.is_heavy_index }
+    end
+
+    def get_refresh_interval(settings, index_name)
+      settings.fetch(index_name, {}).fetch("settings", {}).fetch("index", {}).fetch("refresh_interval", nil)
+    end
+
+    def index_refresh_disabled?(refresh_interval)
+      refresh_interval == "-1"
+    end
+
+    def indexing_allowed?
+      heavy_indices.each do |h_index_name|
+        next if h_index_name == name
+
+        indices_with_aliases = indices.select { |_, index| !index["aliases"].empty? }
+        next if indices_with_aliases.empty?
+
+        indices_with_aliases.each do |index_name, _|
+          settings = get_settings(index_name)
+          refresh_interval = get_refresh_interval(settings, index_name)
+          return false if index_refresh_disabled?(refresh_interval)
+        end
+      end
+
+      true
+    end
+
+    # Searchkick.client.indices.get_alias(name: "policy_index_production").keys
+    # Searchkick.client.indices.delete(index: index)
+    def delete(index)
+      client.indices.delete(index: index)
+    end
+
+    def all_values_from_attributes(attrs)
+      normalize_fields(attrs.slice(*columns_to_search).values.compact)
+    end
+
+    def global_index!
+      @is_global = true
+    end
+
+    def is_global?
+      @is_global
+    end
+
+    def show_end_dated_records!
+      @show_end_dated_records = true
+    end
+
+    def show_end_dated_records?
+      @show_end_dated_records || false
+    end
+
+    def keyword_search_index_name
+      @keyword_search_index_name = ["keyword", type.tr("/", "_"), ENV["ENV_NAME"] || ::HasUtils::Env.current_environment].join("_")
+    end
+
+    def index_name
+      @index_name = [type.tr("/", "_"), ENV["ENV_NAME"] || ::HasUtils::Env.current_environment].join("_")
+    end
+
+    def type
+      name.underscore
+    end
+
+    def sql(sql = nil, &block)
+      @sql ||= sql || (block && block.call)
+    end
+
+    def active_record
+      @active_record ||= begin
+                           ar = Class.new(::ActiveRecord::Base)
+                           ar.primary_key = "id"
+                           ar.table_name = view_name
+                           ar.inheritance_column = nil
+                           ar
+                         end
+    end
+
+    def columns_to_search
+      @columns_to_search ||= active_record.columns.
+        reject { |column| EXCLUDED_SEARCH_TYPES.include?(column.type) || column.name =~ /_id[s]?$/ }.
+        map { |column| column.name.to_sym }
+    end
+
+    def fields
+      @fields ||= active_record.columns.map { |column| column.name.to_sym }
+    end
+
+    def filters
+      @filters
+    end
+
+    def filters=(filters)
+      @filters = filters.map(&:to_sym)
+    end
+
+    def view_name
+      "#{name.underscore.tr("/", "_")}_view"
+    end
+
+    def keyword_search_field_regex
+      # Sorting by longest length to avoid fields whose names are part of another field from taking priority.
+      # For example, if name was before code_name in the regex, then code_name:test would match on name:test
+      @keyword_search_field_regex ||= columns_to_search.sort_by(&:length).reverse.join(":|") + ":"
+    end
+
+    private
+
+    def add_dependency(klass:, from_key: nil, to_key: nil, dependent_attributes: nil, dependency_inheritance: nil)
+      from_column = from_key || (dependency_inheritance.blank? ? model.name.foreign_key : "id")
+      to_column = to_key || "id"
+      index_model = model
+      klass.class_eval do
+        after_commit ->(obj) do
+          index_model.process_dependencies(
+            obj,
+            from_column,
+            to_column,
+            index_model,
+            dependent_attributes,
+            dependency_inheritance,
+            obj.previous_changes
+          )
+        end
+
+        define_inheritance_search(klass)
+      end
+      { "#{klass.name}": { from: from_column, to: to_column, dependent_attributes: dependent_attributes, dependency_inheritance: dependency_inheritance } }
+    end
+
+    def normalize_fields(fields)
+      fields.map do |field|
+        field.is_a?(Array) ? normalize_fields(field) : field.to_s
+      end
+    end
+
+    def configure
+      index_klass = self
+      idx_name = index_name
+      keyword_idx_name = keyword_search_index_name
+
+      model.class_eval do
+        after_commit -> (obj) {
+          obj.reindex
+        }
+
+        define_singleton_method :elasticsearch do |query, **options|
+          index_klass.search query, **options
+        end
+
+        # Access the search index class from the model.
+        # Example: `Advisor.search_index` => `AdvisorIndex`
+        define_singleton_method :search_index do
+          index_klass
+        end
+
+        define_method :reindex do
+          key = HasHelpers::Index.before_index(self)
+          routing_key = index_klass.is_global? ? 0 : self.try(:organization_id)
+          index_klass.reindex_queue.push(self.id.to_s, key, routing_key: routing_key)
+          index_klass.keyword_reindex_queue.push(self.id.to_s, key, routing_key: routing_key)
+          ElasticsearchProcessQueue.perform_async(index_klass.name, idx_name)
+          ElasticsearchProcessQueue.perform_async(index_klass.name, keyword_idx_name)
+        end
+      end
+    end
+
+    def client
+      Searchkick.client
+    end
+
+    def create(name, options = settings)
+      client.indices.create index: name, body: options, include_type_name: true
+    end
+
+    # Searchkick has no easy way of defaulting indices to "word_start", so we have
+    # to use manual mappings. This is a step in the direction of not needing searchkick.
+    # TODO: Add an entry for each "filter", with include_in_all set to false. This will prevent
+    # searching filters.
+    def settings
+      super_settings = {
+        settings: {
+          index: {
+            max_ngram_diff: MAX_NGRAM_DIFF
+          },
+          analysis: {
+            analyzer: {
+              searchkick_index: {
+                type: "custom",
+                tokenizer: "classic",
+                filter: ["lowercase", "asciifolding", "searchkick_index_shingle"]
+              },
+              searchkick_search: {
+                type: "custom",
+                tokenizer: "classic",
+                filter: ["lowercase", "asciifolding", "searchkick_search_shingle"]
+              },
+              searchkick_search2: {
+                type: "custom",
+                tokenizer: "standard",
+                filter: ["lowercase", "asciifolding"]
+              },
+              classic_search: {
+                type: "custom",
+                tokenizer: "classic",
+                filter: ["lowercase", "asciifolding"]
+              },
+              searchkick_word_middle_index: {
+                type: "custom",
+                tokenizer: "classic",
+                filter: ["lowercase", "asciifolding", "searchkick_ngram"]
+              },
+              keyword_index: {
+                type: "custom",
+                tokenizer: "keyword",
+                filter: ["lowercase", "asciifolding"]
+              },
+              keyword_search: {
+                type: "custom",
+                tokenizer: "keywords_with_quotes",
+                filter: ["lowercase", "asciifolding"]
+              }
+            },
+            tokenizer: {
+              keywords_with_quotes: {
+                type: "pattern",
+                pattern: /"((?:\\"|[^"]|\\")*)"/,
+                group: 1
+              }
+            },
+            filter: {
+              searchkick_index_shingle: {
+                type: "shingle",
+                token_separator: ""
+              },
+              searchkick_search_shingle: {
+                type: "shingle",
+                token_separator: "",
+                output_unigrams: false,
+                output_unigrams_if_no_shingles: true
+              },
+              searchkick_ngram: {
+                type: "ngram",
+                min_gram: MIN_NGRAM_SIZE,
+                max_gram: MAX_NGRAM_SIZE
+              }
+            },
+            char_filter: {
+              ampersand: {
+                type: "mapping",
+                mappings: ["\u0026=\u003e and "]
+              }
+            }
+          }
+        },
+        mappings: {
+          type => {
+            properties: {
+              "#{weighted_attr}": {
+                type: "date"
+              }
+            },
+            _routing: {
+              required: true
+            },
+            dynamic_templates: [
+              {
+                name_template: {
+                  match: "name",
+                  match_mapping_type: "string",
+                  mapping: {
+                    type: "keyword",
+                    ignore_above: 30000,
+                    fields: {
+                      analyzed: {
+                        type: "text",
+                        analyzer: "searchkick_word_middle_index"
+                      }
+                    }
+                  }
+                }
+              }, {
+                all_fields_template: {
+                  match: "all_fields",
+                  mapping: {
+                    type: "keyword",
+                    fields: {
+                      analyzed: {
+                        type: "text",
+                        analyzer: "searchkick_word_middle_index"
+                      },
+                      keyword: {
+                        type: "text",
+                        analyzer: "keyword_index"
+                      }
+                    }
+                  }
+                }
+              }, {
+                string_template: {
+                  match: "*",
+                  match_mapping_type: "string",
+                  mapping: {
+                    type: "keyword",
+                    ignore_above: 30000,
+                    fields: {
+                      analyzed: {
+                        type: "text",
+                        analyzer: "searchkick_index"
+                      }
+                    }
+                  }
+                }
+              }
+            ]
+          }
+        }
+      }
+      # Disable indexing for `result_type` to reduce heap usage and avoid unnecessary mapping overhead.
+      # This field is used only for rendering search results and does not need to be searchable.
+      # With `enabled: false`, it remains in _source but is excluded from indexing and analysis.
+      super_settings.deep_merge(
+        mappings: {
+          type => {
+            properties: {
+              result_type: { type: "object", enabled: false }
+            }
+          }
+        }
+      )
+    end
+
+    def keyword_index_settings
+      keyword_settings = settings
+      keyword_settings[:mappings][type][:dynamic_templates] = [
+        {
+          string_template: {
+            match: "*",
+            unmatch: "*id",
+            match_mapping_type: "string",
+            mapping: {
+              type: "keyword",
+              ignore_above: 30000,
+              fields: {
+                wildcard_index: {
+                  type: "text",
+                  analyzer: "searchkick_word_middle_index"
+                },
+                keyword: {
+                  type: "text",
+                  analyzer: "keyword_index"
+                }
+              }
+            }
+          }
+        }, {
+          string_template: {
+            match: "*id",
+            match_mapping_type: "string",
+            mapping: {
+              type: "keyword",
+              ignore_above: 30000,
+              fields: {
+                keyword: {
+                  type: "text",
+                  analyzer: "keyword_index"
+                }
+              }
+            }
+          }
+        }
+      ]
+      keyword_settings
+    end
+  end
+
+  module ActiveRecord
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def search_index
+        "#{self.base_class.name}Index".constantize
+      rescue
+        raise HasHelpers::Index::Error, "Index not defined for #{self.name}"
+      end
+
+      def process_dependencies(obj, from_column, to_column, index_model, dependent_attributes, dependency_inheritance, previous_changes)
+        if (id = obj.read_attribute(from_column)) &&
+           (dependent_attributes.nil? || (previous_changes.keys & dependent_attributes).any?)
+
+          if previous_changes[from_column]
+            index_model.where("#{to_column}": previous_changes[from_column].reject(&:nil?)).find_each(&:reindex)
+          else
+            index_model.find_by("#{to_column}": id)&.reindex
+          end
+          if dependency_inheritance.present?
+            dependency_inheritance.each do |keys|
+              keys_copy = keys.dup
+              obj.inheritance_search(keys_copy, id, index_model).reject(&:nil?).each(&:reindex)
+            end
+          end
+        end
+      end
+
+      def define_inheritance_search(model_class)
+        model_class.class_eval do
+          define_method("inheritance_search") do |dependency_array, id, model|
+            keys = dependency_array.pop
+            inner_to_column = keys[:to] || "id"
+            target = keys[:target].to_s.safe_constantize
+
+            if dependency_array.empty?
+              target.where("#{inner_to_column}": id)
+            else
+              target.where("#{inner_to_column}": inheritance_search(dependency_array, id, model).ids)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+::ActiveRecord::Base.include(HasHelpers::Index::ActiveRecord)