Module: Mongoid::SearchIndexable::ClassMethods

# File 'lib/mongoid/search_indexable.rb', line 161

def create_search_indexes
  return if search_index_specs.empty?

  Threaded.with_collection_management do
    collection.search_indexes.create_many(search_index_specs)
  end
end

# File 'lib/mongoid/search_indexable.rb', line 423

def get_indexes(names)
  collection.search_indexes.select { |i| names.include?(i['name']) }
end

# File 'lib/mongoid/search_indexable.rb', line 525

def infer_auto_embed_path(spec)
  field_list = spec.dig(:definition, :fields) || spec.dig(:definition, 'fields') || []
  ae_field   = field_list.find { |f| (f[:type] || f['type']) == 'autoEmbed' }

  unless ae_field
    raise ArgumentError,
          "Cannot infer path on #{name}: no 'autoEmbed' field in index definition; specify path:"
  end

  (ae_field[:path] || ae_field['path']).to_s
end

# File 'lib/mongoid/search_indexable.rb', line 463

def infer_vector_path(spec)
  field_list = spec.dig(:definition, :fields) || spec.dig(:definition, 'fields') || []
  vector_field = field_list.find { |f| (f[:type] || f['type']) == 'vector' }

  unless vector_field
    raise ArgumentError,
          "Cannot infer vector path on #{name}: no 'vector' type field in index definition; specify path:"
  end

  (vector_field[:path] || vector_field['path']).to_s
end

# File 'lib/mongoid/search_indexable.rb', line 207

def remove_search_index(name: nil, id: nil)
  Threaded.with_collection_management do
    logger.info(
      "MONGOID: Removing search index '#{name || id}' " \
      "on collection '#{collection.name}'."
    )

    collection.search_indexes.drop_one(name: name, id: id)
  end
end

# File 'lib/mongoid/search_indexable.rb', line 230

def remove_search_indexes
  search_indexes.each do |spec|
    remove_search_index id: spec['id']
  end
end

# File 'lib/mongoid/search_indexable.rb', line 482

def resolve_auto_embed_index(index, path)
  auto_embed_specs = search_index_specs.select do |s|
    s[:type] == 'vectorSearch' &&
      (s.dig(:definition, :fields) || s.dig(:definition, 'fields') || [])
        .any? { |f| (f[:type] || f['type']) == 'autoEmbed' }
  end

  raise ArgumentError, "No auto-embed indexes declared on #{name}" if auto_embed_specs.empty?

  # Extracted to keep cyclomatic complexity within RuboCop's threshold.
  spec = select_auto_embed_spec(auto_embed_specs, index)
  resolved_index = spec[:name] || 'default'
  resolved_path  = path ? path.to_s : infer_auto_embed_path(spec)

  [ resolved_index, resolved_path ]
end

# File 'lib/mongoid/search_indexable.rb', line 434

def resolve_vector_index(index, path)
  vector_specs = search_index_specs.select { |s| s[:type] == 'vectorSearch' }

  raise ArgumentError, "No vector search indexes declared on #{name}" if vector_specs.empty?

  spec = if index
           found = vector_specs.find { |s| s[:name] == index.to_s }
           raise ArgumentError, "No vector search index '#{index}' declared on #{name}" unless found

           found
         elsif vector_specs.size == 1
           vector_specs.first
         else
           raise ArgumentError,
                 "#{name} has multiple vector search indexes; specify index: to select one"
         end

  resolved_index = spec[:name] || 'default'
  resolved_path  = path ? path.to_s : infer_vector_path(spec)

  [ resolved_index, resolved_path ]
end

# File 'lib/mongoid/search_indexable.rb', line 249

def search_index(name_or_defn, defn = nil)
  name = name_or_defn
  name, defn = nil, name if name.is_a?(Hash)

  spec = { definition: defn }.tap { |s| s[:name] = name.to_s if name }
  search_index_specs.push(spec)
end

# File 'lib/mongoid/search_indexable.rb', line 196

def search_indexes(options = {})
  Threaded.with_collection_management do
    collection.search_indexes(options)
  end
end

# File 'lib/mongoid/search_indexable.rb', line 505

def select_auto_embed_spec(specs, index)
  if index
    found = specs.find { |s| s[:name] == index.to_s }
    raise ArgumentError, "No auto-embed index '#{index}' declared on #{name}" unless found

    found
  elsif specs.size == 1
    specs.first
  else
    raise ArgumentError,
          "#{name} has multiple auto-embed indexes; specify index: to select one"
  end
end

# File 'lib/mongoid/search_indexable.rb', line 407

def validate_vector_index_definition!(defn)
  fields = defn[:fields] || defn['fields'] || []
  fields.each do |field|
    method = field[:indexingMethod] || field['indexingMethod']
    next unless method.to_s == 'flat'
    next unless field[:hnswOptions] || field['hnswOptions']

    raise ArgumentError, 'hnswOptions is only supported with indexingMethod: hnsw'
  end
end

# File 'lib/mongoid/search_indexable.rb', line 324

def vector_search(vector, index: nil, path: nil, limit: 10, num_candidates: nil, exact: false, filter: nil, pipeline: []) # rubocop:disable Metrics/ParameterLists
  resolved_index, resolved_path = resolve_vector_index(index, path)

  vs_options = {
    'index' => resolved_index,
    'path' => resolved_path,
    'queryVector' => vector,
    'limit' => limit
  }
  vs_options['numCandidates'] = num_candidates || (limit * 10) unless exact
  vs_options['exact'] = true if exact
  vs_options['filter'] = filter if filter

  agg_pipeline = [
    { '$vectorSearch' => vs_options },
    { '$addFields'    => { 'vector_search_score' => { '$meta' => 'vectorSearchScore' } } },
    { '$project'      => { resolved_path => 0 } }
  ]
  agg_pipeline.concat(Array(pipeline))

  collection.aggregate(agg_pipeline).map { |doc| instantiate(doc) }
end

# File 'lib/mongoid/search_indexable.rb', line 280

def vector_search_index(name_or_defn, defn = nil)
  name = name_or_defn
  name, defn = nil, name if name.is_a?(Hash)

  validate_vector_index_definition!(defn)

  spec = { type: 'vectorSearch', definition: defn }.tap { |s| s[:name] = name.to_s if name }
  search_index_specs.push(spec)

  return if fields.key?('vector_search_score')

  field :vector_search_score, type: Float
  attr_readonly :vector_search_score
end

# File 'lib/mongoid/search_indexable.rb', line 176

def wait_for_search_indexes(names, interval: 5)
  loop do
    status = Status.new(get_indexes(names))
    yield status if block_given?
    break if status.ready?

    sleep interval
  end
end