Module: Typesense::ClassMethods

Defined in:
lib/typesense-rails.rb

Overview

these are the class methods added when Typesense is included

Defined Under Namespace

Modules: AdditionalMethods

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extended(base) ⇒ Object 



240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'lib/typesense-rails.rb', line 240

def self.extended(base)
  class << base
    alias_method :without_auto_index, :typesense_without_auto_index unless method_defined? :without_auto_index
    alias_method :reindex!, :typesense_reindex! unless method_defined? :reindex!
    alias_method :reindex, :typesense_reindex unless method_defined? :reindex
    alias_method :index_objects, :typesense_index_objects unless method_defined? :index_objects
    alias_method :index!, :typesense_index! unless method_defined? :index!
    alias_method :remove_from_index!, :typesense_remove_from_index! unless method_defined? :remove_from_index!
    alias_method :clear_index!, :typesense_clear_index! unless method_defined? :clear_index!
    alias_method :search, :typesense_search unless method_defined? :search
    alias_method :raw_search, :typesense_raw_search unless method_defined? :raw_search
    alias_method :index, :typesense_index unless method_defined? :index
    alias_method :index_name, :typesense_collection_name unless method_defined? :index_name
    alias_method :collection_name, :typesense_collection_name unless method_defined? :collection_name
    alias_method :must_reindex?, :typesense_must_reindex? unless method_defined? :must_reindex?
    alias_method :create_collection, :typesense_create_collection unless method_defined? :create_collection
    alias_method :upsert_alias, :typesense_upsert_alias unless method_defined? :upsert_alias
    alias_method :get_collection, :typesense_get_collection unless method_defined? :get_collection
    alias_method :num_documents, :typesense_num_documents unless method_defined? :num_documents
    alias_method :get_alias, :typesense_get_alias unless method_defined? :get_alias
    alias_method :upsert_document, :typesense_upsert_document unless method_defined? :upsert_document
    alias_method :import_documents, :typesense_import_documents unless method_defined? :import_documents
    alias_method :retrieve_document, :typesense_retrieve_document unless method_defined? :retrieve_document
    alias_method :delete_document, :typesense_delete_document unless method_defined? :delete_document
    alias_method :delete_collection, :typesense_delete_collection unless method_defined? :delete_collection
    alias_method :delete_by_query, :typesense_delete_by_query unless method_defined? :delete_by_query
    alias_method :search_collection, :typesense_search_collection unless method_defined? :search_collection
  end

  base.cattr_accessor :typesense_options, :typesense_settings, :typesense_client
end

Instance Method Details

#apply_typesense_collection_resources(collection_name, multi_way_synonyms: nil, one_way_synonyms: nil, synonym_sets: nil, curation_sets: nil, existing_collection: nil) ⇒ Object 



397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
 
# File 'lib/typesense-rails.rb', line 397

def apply_typesense_collection_resources(collection_name, multi_way_synonyms: nil, one_way_synonyms: nil, synonym_sets: nil, curation_sets: nil, existing_collection: nil)
  if typesense_server_major_version >= 30
    apply_v30_collection_resources(
      collection_name,
      multi_way_synonyms: multi_way_synonyms,
      one_way_synonyms: one_way_synonyms,
      synonym_sets: synonym_sets,
      curation_sets: curation_sets,
      existing_collection: existing_collection
    )
  else
    ensure_v30_resource_support!(synonym_sets, curation_sets)
    typesense_multi_way_synonyms(collection_name, multi_way_synonyms) if multi_way_synonyms
    typesense_one_way_synonyms(collection_name, one_way_synonyms) if one_way_synonyms
  end
end

#apply_v30_collection_resources(collection_name, multi_way_synonyms: nil, one_way_synonyms: nil, synonym_sets: nil, curation_sets: nil, existing_collection: nil) ⇒ Object 



414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
 
# File 'lib/typesense-rails.rb', line 414

def apply_v30_collection_resources(collection_name, multi_way_synonyms: nil, one_way_synonyms: nil, synonym_sets: nil, curation_sets: nil, existing_collection: nil)
  inline_synonyms_present = multi_way_synonyms || one_way_synonyms
  attached_synonym_sets = Array(existing_collection && existing_collection["synonym_sets"]) + Array(synonym_sets)
  attached_curation_sets = Array(existing_collection && existing_collection["curation_sets"]) + Array(curation_sets)

  if inline_synonyms_present
    synonym_set_name = default_synonym_set_name(collection_name)
    ensure_synonym_set_exists(synonym_set_name)
    upsert_synonym_set_items(synonym_set_name, multi_way_synonyms, one_way_synonyms)
    attached_synonym_sets << synonym_set_name
  end

  collection_patch = {}
  collection_patch["synonym_sets"] = attached_synonym_sets.uniq if attached_synonym_sets.any?
  collection_patch["curation_sets"] = attached_curation_sets.uniq if attached_curation_sets.any?

  return if collection_patch.empty?

  typesense_client.collections[collection_name].update(collection_patch)
end

#collection_name_with_timestamp(options) ⇒ Object 



272
273
274
 
# File 'lib/typesense-rails.rb', line 272

def collection_name_with_timestamp(options)
  "#{typesense_collection_name(options)}_#{Time.now.to_i}_#{SecureRandom.hex(4)}"
end

#default_synonym_set_name(collection_name) ⇒ Object 



444
445
446
 
# File 'lib/typesense-rails.rb', line 444

def default_synonym_set_name(collection_name)
  "#{collection_name}_synonyms_index"
end

#ensure_synonym_set_exists(synonym_set_name) ⇒ Object 



448
449
450
 
# File 'lib/typesense-rails.rb', line 448

def ensure_synonym_set_exists(synonym_set_name)
  typesense_client.synonym_sets.upsert(synonym_set_name, { "items" => [] })
end

#ensure_v30_resource_support!(synonym_sets, curation_sets) ⇒ Object

Raises:



435
436
437
438
439
440
441
442
 
# File 'lib/typesense-rails.rb', line 435

def ensure_v30_resource_support!(synonym_sets, curation_sets)
  unsupported = []
  unsupported << "synonym_sets" if synonym_sets
  unsupported << "curation_sets" if curation_sets
  return if unsupported.empty?

  raise Typesense::BadConfiguration, "#{unsupported.join(' and ')} require Typesense v30.0 or newer"
end

#reset_typesense_server_major_version! ⇒ Object 



474
475
476
 
# File 'lib/typesense-rails.rb', line 474

def reset_typesense_server_major_version!
  Typesense.reset_server_version_cache!
end

#typesense(options = {}, &block) ⇒ Object 



494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
 
# File 'lib/typesense-rails.rb', line 494

def typesense(options = {}, &block)
  self.typesense_settings = IndexSettings.new(options, &block)
  self.typesense_options = { type: typesense_full_const_get(model_name.to_s) }.merge(options) # :per_page => typesense_settings.get_setting(:hitsPerPage) || 10, :page => 1
  self.typesense_client ||= Typesense.client
  attr_accessor :highlight_result, :snippet_result

  if options[:enqueue]
    proc = if options[:enqueue] == true
        proc do |record, remove|
          TypesenseJob.perform_later(record, remove ? "typesense_remove_from_index!" : "typesense_index!")
        end
      elsif options[:enqueue].respond_to?(:call)
        options[:enqueue]
      elsif options[:enqueue].is_a?(Symbol)
        proc { |record, remove| send(options[:enqueue], record, remove) }
      else
        raise ArgumentError, "Invalid `enqueue` option: #{options[:enqueue]}"
      end
    typesense_options[:enqueue] = proc do |record, remove|
      proc.call(record, remove) unless typesense_without_auto_index_scope
    end
  end
  unless options[:auto_index] == false
    if defined?(::Sequel) && self < Sequel::Model
      class_eval do
        copy_after_validation = instance_method(:after_validation)
        copy_before_save = instance_method(:before_save)

        define_method(:after_validation) do |*args|
          super(*args)
          copy_after_validation.bind(self).call
          typesense_mark_must_reindex
        end

        define_method(:before_save) do |*args|
          copy_before_save.bind(self).call
          typesense_mark_for_auto_indexing
          super(*args)
        end

        sequel_version = Gem::Version.new(Sequel.version)
        if sequel_version >= Gem::Version.new("4.0.0") && sequel_version < Gem::Version.new("5.0.0")
          copy_after_commit = instance_method(:after_commit)
          define_method(:after_commit) do |*args|
            super(*args)
            copy_after_commit.bind(self).call
            typesense_perform_index_tasks
          end
        else
          copy_after_save = instance_method(:after_save)
          define_method(:after_save) do |*args|
            super(*args)
            copy_after_save.bind(self).call
            db.after_commit do
              typesense_perform_index_tasks
            end
          end
        end
      end
    else
      after_validation :typesense_mark_must_reindex if respond_to?(:after_validation)
      before_save :typesense_mark_for_auto_indexing if respond_to?(:before_save)
      if respond_to?(:after_commit)
        after_commit :typesense_perform_index_tasks
      elsif respond_to?(:after_save)
        after_save :typesense_perform_index_tasks
      end
    end
  end
  unless options[:auto_remove] == false
    if defined?(::Sequel) && self < Sequel::Model
      class_eval do
        copy_after_destroy = instance_method(:after_destroy)

        define_method(:after_destroy) do |*args|
          copy_after_destroy.bind(self).call
          typesense_enqueue_remove_from_index!
          super(*args)
        end
      end
    elsif respond_to?(:after_destroy)
      after_destroy { |searchable| searchable.typesense_enqueue_remove_from_index! }
    end
  end
end

#typesense_clear_index! ⇒ Object 



760
761
762
763
764
765
766
767
768
769
770
771
772
 
# File 'lib/typesense-rails.rb', line 760

def typesense_clear_index!
  # typesense_clear_index!: Delete collection of given model.
  typesense_configurations.each do |options, settings|
    next if typesense_indexing_disabled?(options)

    collection_obj = typesense_ensure_init(options, settings, false)

    delete_collection(collection_obj[:alias_name])
    Typesense.log(:debug, "Deleted #{collection_obj[:alias_name]} collection!")
    @typesense_indexes[settings] = nil
  end
  nil
end

#typesense_collection_name(options = nil) ⇒ Object 



850
851
852
853
854
855
 
# File 'lib/typesense-rails.rb', line 850

def typesense_collection_name(options = nil)
  options ||= typesense_options
  name = options[:collection_name] || options[:index_name] || model_name.to_s.gsub("::", "_")
  name = "#{name}_#{Rails.env}" if options[:per_environment]
  name
end

#typesense_collection_resources(collection_name) ⇒ Object 



482
483
484
485
486
487
488
489
490
491
492
 
# File 'lib/typesense-rails.rb', line 482

def typesense_collection_resources(collection_name)
  return {} if typesense_server_major_version < 30

  collection = typesense_get_collection(collection_name)
  return {} unless collection

  {
    "synonym_sets" => Array(collection["synonym_sets"]),
    "curation_sets" => Array(collection["curation_sets"])
  }
end

#typesense_create_collection(collection_name, settings = nil, existing_collection: nil) ⇒ Object 



276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
 
# File 'lib/typesense-rails.rb', line 276

def typesense_create_collection(collection_name, settings = nil, existing_collection: nil)
  fields = settings.get_setting(:predefined_fields) || settings.get_setting(:fields)
  default_sorting_field = settings.get_setting(:default_sorting_field)
  multi_way_synonyms = settings.get_setting(:multi_way_synonyms)
  one_way_synonyms = settings.get_setting(:one_way_synonyms)
  synonym_sets = settings.get_setting(:synonym_sets)
  curation_sets = settings.get_setting(:curation_sets)
  symbols_to_index = settings.get_setting(:symbols_to_index)
  token_separators = settings.get_setting(:token_separators)
  enable_nested_fields = settings.get_setting(:enable_nested_fields)
  metadata = settings.get_setting(:metadata)
  typesense_client.collections.create(
    { "name" => collection_name }
      .merge(
        if fields
          { "fields" => fields }
        else
          { "fields" => [
            { "name" => ".*",
              "type" => "auto" },
          ] }
        end,
        default_sorting_field ? { "default_sorting_field" => default_sorting_field } : {},
        symbols_to_index ? { "symbols_to_index" => symbols_to_index } : {},
        token_separators ? { "token_separators" => token_separators } : {},
        enable_nested_fields ? { "enable_nested_fields" => enable_nested_fields } : {},
        metadata ? { "metadata" => metadata } : {}
      )
  )
  Typesense.log(:debug, "Collection '#{collection_name}' created!")

  apply_typesense_collection_resources(
    collection_name,
    multi_way_synonyms: multi_way_synonyms,
    one_way_synonyms: one_way_synonyms,
    synonym_sets: synonym_sets,
    curation_sets: curation_sets,
    existing_collection: existing_collection
  )
end

#typesense_debug_info ⇒ Object 



478
479
480
 
# File 'lib/typesense-rails.rb', line 478

def typesense_debug_info
  Typesense.debug_info
end

#typesense_delete_by_query(collection, query) ⇒ Object 



363
364
365
 
# File 'lib/typesense-rails.rb', line 363

def typesense_delete_by_query(collection, query)
  typesense_client.collections[collection].documents.delete(filter_by: query)
end

#typesense_delete_collection(collection) ⇒ Object 



367
368
369
 
# File 'lib/typesense-rails.rb', line 367

def typesense_delete_collection(collection)
  typesense_client.collections[collection].delete
end

#typesense_delete_document(object_id, collection) ⇒ Object 



359
360
361
 
# File 'lib/typesense-rails.rb', line 359

def typesense_delete_document(object_id, collection)
  typesense_client.collections[collection].documents[object_id].delete
end

#typesense_get_alias(alias_name) ⇒ Object 



331
332
333
 
# File 'lib/typesense-rails.rb', line 331

def typesense_get_alias(alias_name)
  typesense_client.aliases[alias_name].retrieve
end

#typesense_get_collection(collection) ⇒ Object 



321
322
323
324
325
 
# File 'lib/typesense-rails.rb', line 321

def typesense_get_collection(collection)
  typesense_client.collections[collection].retrieve
rescue Typesense::Error::ObjectNotFound
  nil
end

#typesense_import_documents(jsonl_object, action, collection, batch_size: nil) ⇒ Object

Raises:

  • (ArgumentError) 


342
343
344
345
346
347
348
 
# File 'lib/typesense-rails.rb', line 342

def typesense_import_documents(jsonl_object, action, collection, batch_size: nil)
  raise ArgumentError, "JSONL object is required" unless jsonl_object
  import_options = { action: action }
  import_options[:batch_size] = batch_size if batch_size

  typesense_client.collections[collection].documents.import(jsonl_object, import_options)
end

#typesense_index(name = nil) ⇒ Object 



839
840
841
842
843
844
845
846
847
848
 
# File 'lib/typesense-rails.rb', line 839

def typesense_index(name = nil)
  # typesense_index: Creates collection and its alias.
  if name
    typesense_configurations.each do |o, s|
      return typesense_ensure_init(o, s) if o[:collection_name].to_s == name.to_s || o[:index_name].to_s == name.to_s
    end
    raise ArgumentError, "Invalid index/replica name: #{name}"
  end
  typesense_ensure_init
end

#typesense_index!(object) ⇒ Object 



704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
 
# File 'lib/typesense-rails.rb', line 704

def typesense_index!(object)
  # typesense_index!: Creates a document for the object and retrieves it.
  return if typesense_without_auto_index_scope

  api_response = nil

  typesense_configurations.each do |options, settings|
    next if typesense_indexing_disabled?(options)

    object_id = typesense_object_id_of(object, options)
    collection_obj = typesense_ensure_init(options, settings)

    if typesense_indexable?(object, options)
      raise ArgumentError, "Cannot index a record with a blank objectID" if object_id.blank?

      object = settings.get_attributes(object).merge!("id" => object_id)

      if options[:dirty_values]
        api_response = upsert_document(object, collection_obj[:alias_name], options[:dirty_values])
      else
        api_response = upsert_document(object, collection_obj[:alias_name])
      end
    elsif typesense_conditional_index?(options) && !object_id.blank?
      begin
        api_response = delete_document(object_id, collection_obj[:collection_name])
      rescue Typesense::Error::ObjectNotFound => e
        Typesense.log(:error, "Object not found in index: #{e.message}")
      end
    end
  end

  api_response
end

#typesense_index_objects(objects, batch_size = Typesense::IndexSettings::DEFAULT_BATCH_SIZE) ⇒ Object 



689
690
691
692
693
694
695
696
697
698
699
700
701
702
 
# File 'lib/typesense-rails.rb', line 689

def typesense_index_objects(objects, batch_size = Typesense::IndexSettings::DEFAULT_BATCH_SIZE)
  typesense_configurations.each do |options, settings|
    next if typesense_indexing_disabled?(options)

    collection_obj = typesense_ensure_init(options, settings)
    documents = objects.map do |o|
      settings.get_attributes(o).merge!("id" => typesense_object_id_of(o, options)).to_json
    end
    jsonl_object = documents.join("\n")
    import_documents(jsonl_object, "upsert", collection_obj[:alias_name], batch_size: batch_size)
    Typesense.log(:debug, "#{objects.length} objects upserted into #{collection_obj[:collection_name]}!")
  end
  nil
end

#typesense_index_objects_async(objects, batch_size = Typesense::IndexSettings::DEFAULT_BATCH_SIZE) ⇒ Object 



675
676
677
678
679
680
681
682
683
684
685
686
687
 
# File 'lib/typesense-rails.rb', line 675

def typesense_index_objects_async(objects, batch_size = Typesense::IndexSettings::DEFAULT_BATCH_SIZE)
  typesense_configurations.each do |options, settings|
    next if typesense_indexing_disabled?(options)
    collection_obj = typesense_ensure_init(options, settings)
    documents = objects.map do |o|
      settings.get_attributes(o).merge!("id" => typesense_object_id_of(o, options)).to_json
    end
    jsonl_object = documents.join("\n")
    ImportJob.perform(jsonl_object, collection_obj[:alias_name], batch_size)
    Typesense.log(:debug, "#{objects.length} objects enqueued for import into #{collection_obj[:collection_name]}")
  end
  nil
end

#typesense_multi_way_synonyms(collection, synonyms) ⇒ Object 



375
376
377
378
379
380
381
382
383
384
 
# File 'lib/typesense-rails.rb', line 375

def typesense_multi_way_synonyms(collection, synonyms)
  synonyms.each do |synonym_hash|
    synonym_hash.each do |synonym_name, synonym|
      typesense_client.collections[collection].synonyms.upsert(
        synonym_name,
        { "synonyms" => synonym }
      )
    end
  end
end

#typesense_must_reindex?(object) ⇒ Boolean

Returns:

  • (Boolean) 


857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
 
# File 'lib/typesense-rails.rb', line 857

def typesense_must_reindex?(object)
  # use +typesense_dirty?+ method if implemented
  return object.send(:typesense_dirty?) if object.respond_to?(:typesense_dirty?)

  # Loop over each index to see if a attribute used in records has changed
  typesense_configurations.each do |options, settings|
    next if typesense_indexing_disabled?(options)
    return true if typesense_object_id_changed?(object, options)

    settings.get_attribute_names(object).each do |k|
      return true if typesense_attribute_changed?(object, k)
      # return true if !object.respond_to?(changed_method) || object.send(changed_method)
    end
    [options[:if], options[:unless]].each do |condition|
      case condition
      when nil
      when String, Symbol
        return true if typesense_attribute_changed?(object, condition)
      else
        # if the :if, :unless condition is a anything else,
        # we have no idea whether we should reindex or not
        # let's always reindex then
        return true
      end
    end
  end
  # By default, we don't reindex
  false
end

#typesense_num_documents(collection) ⇒ Object 



327
328
329
 
# File 'lib/typesense-rails.rb', line 327

def typesense_num_documents(collection)
  typesense_client.collections[collection].retrieve["num_documents"]
end

#typesense_one_way_synonyms(collection, synonyms) ⇒ Object 



386
387
388
389
390
391
392
393
394
395
 
# File 'lib/typesense-rails.rb', line 386

def typesense_one_way_synonyms(collection, synonyms)
  synonyms.each do |synonym_hash|
    synonym_hash.each do |synonym_name, synonym|
      typesense_client.collections[collection].synonyms.upsert(
        synonym_name,
        synonym
      )
    end
  end
end

#typesense_raw_search(q, query_by, params = {}) ⇒ Object 



774
775
776
777
778
779
 
# File 'lib/typesense-rails.rb', line 774

def typesense_raw_search(q, query_by, params = {})
  # typesense_raw_search: JSON output of search.
  params[:page] = params[:page] ? params[:page].to_i : 1
  collection_obj = typesense_index # index_name)
  search_collection(params.merge({ q: q, query_by: query_by }), collection_obj[:alias_name])
end

#typesense_reindex(batch_size = Typesense::IndexSettings::DEFAULT_BATCH_SIZE) ⇒ Object 



630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
 
# File 'lib/typesense-rails.rb', line 630

def typesense_reindex(batch_size = Typesense::IndexSettings::DEFAULT_BATCH_SIZE)
  # typesense_reindex: Reindexes whole database using alias(removes deleted objects from collection)
  return if typesense_without_auto_index_scope

  typesense_configurations.each do |options, settings|
    next if typesense_indexing_disabled?(options)

    existing_collection_resources = {}
    old_collection_name = nil
    begin
      master_index = typesense_ensure_init(options, settings, false)
      existing_collection_resources = typesense_collection_resources(master_index[:alias_name])
      old_collection_name = master_index[:collection_name]
    rescue ArgumentError
      @typesense_indexes[settings] = { collection_name: "", alias_name: typesense_collection_name(options) }
      master_index = @typesense_indexes[settings]
    end

    # init temporary index
    src_index_name = collection_name_with_timestamp(options)
    tmp_options = options.merge({ index_name: src_index_name })
    tmp_options.delete(:per_environment) # already included in the temporary index_name
    tmp_settings = settings.dup

    create_collection(src_index_name, settings, existing_collection: existing_collection_resources)

    typesense_find_in_batches(batch_size) do |group|
      if typesense_conditional_index?(options)
        # select only indexable objects
        group = group.select { |o| typesense_indexable?(o, tmp_options) }
      end
      documents = group.map do |o|
        tmp_settings.get_attributes(o).merge!("id" => typesense_object_id_of(o, tmp_options)).to_json
      end
      jsonl_object = documents.join("\n")
      import_documents(jsonl_object, "upsert", src_index_name)
    end

    upsert_alias(src_index_name, master_index[:alias_name])
    delete_collection(old_collection_name) if old_collection_name.present? && old_collection_name != src_index_name
    master_index[:collection_name] = src_index_name
  end
  nil
end

#typesense_reindex!(batch_size = Typesense::IndexSettings::DEFAULT_BATCH_SIZE) ⇒ Object 



597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
 
# File 'lib/typesense-rails.rb', line 597

def typesense_reindex!(batch_size = Typesense::IndexSettings::DEFAULT_BATCH_SIZE)
  # typesense_reindex!: Reindexes all objects in database(does not remove deleted objects from the collection)
  return if typesense_without_auto_index_scope

  api_response = nil

  typesense_configurations.each do |options, settings|
    next if typesense_indexing_disabled?(options)

    collection_obj = typesense_ensure_init(options, settings)

    typesense_find_in_batches(batch_size) do |group|
      if typesense_conditional_index?(options)
        # delete non-indexable objects
        ids = group.reject { |o| typesense_indexable?(o, options) }.map { |o| typesense_object_id_of(o, options) }
        delete_by_query(collection_obj[:alias_name], "id: [#{ids.reject(&:blank?).join(",")}]")

        group = group.select { |o| typesense_indexable?(o, options) }
      end
      documents = group.map do |o|
        attributes = settings.get_attributes(o)
        attributes = attributes.to_hash unless attributes.instance_of?(Hash)
        # convert to JSON object
        attributes.merge!("id" => typesense_object_id_of(o, options)).to_json
      end

      jsonl_object = documents.join("\n")
      api_response = import_documents(jsonl_object, "upsert", collection_obj[:alias_name])
    end
  end
  api_response
end

#typesense_remove_from_index!(object) ⇒ Object

Raises:

  • (ArgumentError) 


738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
 
# File 'lib/typesense-rails.rb', line 738

def typesense_remove_from_index!(object)
  # typesense_remove_from_index: Removes specified object from the collection of given model.
  return if typesense_without_auto_index_scope

  object_id = typesense_object_id_of(object)
  raise ArgumentError, "Cannot index a record with a blank objectID" if object_id.blank?

  typesense_configurations.each do |options, settings|
    next if typesense_indexing_disabled?(options)

    collection_obj = typesense_ensure_init(options, settings, false)

    begin
      delete_document(object_id, collection_obj[:alias_name])
    rescue Typesense::Error::ObjectNotFound => e
      Typesense.log(:error, "Object #{object_id} could not be removed from #{collection_obj[:collection_name]} collection! Use reindex to update the collection.")
    end
    Typesense.log(:debug, "Removed document with object id '#{object_id}' from #{collection_obj[:collection_name]}")
  end
  nil
end

#typesense_retrieve_document(object_id, collection = nil) ⇒ Object 



350
351
352
353
354
355
356
357
 
# File 'lib/typesense-rails.rb', line 350

def typesense_retrieve_document(object_id, collection = nil)
  if collection
    typesense_client.collections[collection].documents[object_id].retrieve
  else
    collection_obj = typesense_ensure_init
    typesense_client.collections[collection_obj[:alias_name]].documents[object_id].retrieve
  end
end

#typesense_search(q, query_by, params = {}) ⇒ Object 



804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
 
# File 'lib/typesense-rails.rb', line 804

def typesense_search(q, query_by, params = {})
  # typsense_search: Searches and returns matching objects from the database.

  json = typesense_raw_search(q, query_by, params)
  hit_ids = json["hits"].map { |hit| hit["document"]["id"] }

  condition_key = if defined?(::Mongoid::Document) && include?(::Mongoid::Document)
      typesense_object_id_method.in
    else
      typesense_object_id_method
    end

  results_by_id = typesense_options[:type].where(condition_key => hit_ids).index_by do |hit|
    typesense_object_id_of(hit)
  end

  results = json["hits"].map do |hit|
    o = results_by_id[hit["document"]["id"].to_s]
    next unless o

    o.highlight_result = hit["highlights"]
    o.snippet_result = hit["highlights"].map do |highlight|
      highlight["snippet"]
    end
    o
  end.compact

  total_hits = json["found"]
  res = Typesense::Pagination.create(results, total_hits,
                                     typesense_options.merge({ page: json["page"].to_i, per_page: json["request_params"]["per_page"] }))
  res.extend(AdditionalMethods)
  res.send(:typesense_init_raw_answer, json)
  res
end

#typesense_search_collection(search_parameters, collection) ⇒ Object 



371
372
373
 
# File 'lib/typesense-rails.rb', line 371

def typesense_search_collection(search_parameters, collection)
  typesense_client.collections[collection].documents.search(search_parameters)
end

#typesense_server_major_version ⇒ Object 



470
471
472
 
# File 'lib/typesense-rails.rb', line 470

def typesense_server_major_version
  Typesense.server_major_version
end

#typesense_upsert_alias(collection_name, alias_name) ⇒ Object 



317
318
319
 
# File 'lib/typesense-rails.rb', line 317

def typesense_upsert_alias(collection_name, alias_name)
  typesense_client.aliases.upsert(alias_name, { "collection_name" => collection_name })
end

#typesense_upsert_document(object, collection, dirtyvalues = nil) ⇒ Object

Raises:

  • (ArgumentError) 


335
336
337
338
339
340
 
# File 'lib/typesense-rails.rb', line 335

def typesense_upsert_document(object, collection, dirtyvalues = nil)
  raise ArgumentError, "Object is required" unless object

  typesense_client.collections[collection].documents.upsert(object, dirty_values: dirtyvalues) if dirtyvalues
  typesense_client.collections[collection].documents.upsert(object)
end

#typesense_without_auto_index ⇒ Object 



580
581
582
583
584
585
586
587
 
# File 'lib/typesense-rails.rb', line 580

def typesense_without_auto_index
  self.typesense_without_auto_index_scope = true
  begin
    yield
  ensure
    self.typesense_without_auto_index_scope = false
  end
end

#typesense_without_auto_index_scope ⇒ Object 



593
594
595
 
# File 'lib/typesense-rails.rb', line 593

def typesense_without_auto_index_scope
  Thread.current["typesense_without_auto_index_scope_for_#{model_name}"]
end

#typesense_without_auto_index_scope=(value) ⇒ Object 



589
590
591
 
# File 'lib/typesense-rails.rb', line 589

def typesense_without_auto_index_scope=(value)
  Thread.current["typesense_without_auto_index_scope_for_#{model_name}"] = value
end

#upsert_synonym_set_items(synonym_set_name, multi_way_synonyms, one_way_synonyms) ⇒ Object 



452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
 
# File 'lib/typesense-rails.rb', line 452

def upsert_synonym_set_items(synonym_set_name, multi_way_synonyms, one_way_synonyms)
  items = []

  Array(multi_way_synonyms).each do |synonym_hash|
    synonym_hash.each do |synonym_name, synonym|
      items << { "id" => synonym_name, "synonyms" => synonym }
    end
  end

  Array(one_way_synonyms).each do |synonym_hash|
    synonym_hash.each do |synonym_name, synonym|
      items << synonym.merge("id" => synonym_name)
    end
  end

  typesense_client.synonym_sets.upsert(synonym_set_name, { "items" => items })
end