mongodb_meilisearch 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d42d4314105bccabf3b1cc8dc49c1e7c578cc854d213f8fb73cde81aba26c03
-  data.tar.gz: 0dc187a25352ae68526a389d8e0deed4ba9772ff94a3a6fb2bf001e67f8ccbcb
+  metadata.gz: c7873b1a21e75522aa4fdaa063231997319faae90ddb9a4774cd814bf18a4afc
+  data.tar.gz: b4f241003a1ff709c1247f6411cec39831459795d8e17c429a9b7b187ff790cd
 SHA512:
-  metadata.gz: 13f4ab53d0794010d49bcbdf325db757ceae92cbcce77c77c7dccc99fc4436312b9d786a79fe62609363a8f83372c025374f73cc967261cda231f9624b0e0672
-  data.tar.gz: ef36cb85710a0bcbe4c47747686aa19d0a7d6748000e4f8ed73e1682a01ec7c4166cffc7e0984faeb7d3b25f9c64288943a828888bcb161d24d2d2268ddf9974
+  metadata.gz: 8ad38b1b7f7c14baaee4c12491affeb62c9b9a700ec41d3bddcdf3c095288c084c9bf8f6c9feb28300b441e5fd94380179c9f334c7d2df078d48410221fbc05f
+  data.tar.gz: 5792131d06698d2af16194078e1d5a8bfbf37b9084502f25183d5f3c347d712d2eeac7e604edf0298800a03795e573336adbdc9a5b1d47929691f9288e974027

data/.rubocop.yml

@@ -1116,12 +1116,6 @@ Style/ComparableClamp:
 Style/ConcatArrayLiterals:
   Enabled: false
 
-Style/ConditionalAssignment:
-  Enabled: true
-  EnforcedStyle: assign_to_condition
-  SingleLineConditionsOnly: true
-  IncludeTernaryExpressions: true
-
 Style/ConstantVisibility:
   Enabled: false
 
@@ -1857,3 +1851,11 @@ Style/YodaExpression:
 Style/ZeroLengthPredicate:
   Enabled: false
 
+# this is horrible for readability
+# and maintainability
+Style/ConditionalAssignment:
+  Enabled: false
+
+# I'll nest how I wanna nest! :p
+RSpec/NestedGroups:
+  Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mongodb_meilisearch (1.0.1)
+    mongodb_meilisearch (1.1.1)
       meilisearch
       mongoid (~> 7.0)
       rails

data/README.md

@@ -226,7 +226,8 @@ Then call the following. If `FILTERABLE_ATTRIBUTE_NAMES` is defined it will use
 otherwise it will use whatever `.searchable_attributes` returns.
 
 ```ruby
-MyModel.set_filterable_attributes!
+MyModel.set_filterable_attributes! # synchronous 
+MyModel.set_filterable_attributes  # asynchronous
 ``` 
 
 This will cause Meilisearch to reindex all the records for that index. If you
@@ -235,14 +236,31 @@ on a background thread. Note that filtering is managed at the index level, not t
 record level. By setting filterable attributes you're giving Meilisearch
 guidance on what to do when indexing your data.
 
+Note that you will encounter problems in a shared index if you try and
+filter on a field that one of the contributing models doesn't have set
+as a filterable field, or doesn't have at all.
 
+### Sortable Fields
+
+Sortable fields work in essentially the same way as filterable fields.
+By default it's the same as your `FILTERABLE_ATTRIBUTE_NAMES` which, in turn, defaults to your `SEARCHABLE_ATTRIBUTES` You can
+override it by setting `SORTABLE_ATTRIBUTE_NAMES`. 
+
+Note that you will encounter problems in a shared index if you try and
+sort on a field that one of the contributing models doesn't have set
+as a sortable field, or doesn't have at all.
+
+```ruby
+MyModel.set_sortable_attributes! # synchronous 
+MyModel.set_sortable_attributes  # asynchronous
+``` 
 
 ### Indexing things
 **Important note**: By default anything you do that updates the search index (adding, removing, or changing) happens asynchronously. 
 
 Sometimes, especially when debugging something on the console, you want to
-update the index _synchronously_. The convention used in this codebase is that
-the synchronous methods  are the ones with the bang.  Similar to how mutating
+update the index _synchronously_. The convention used in this codebase - and in the meilisearch-ruby library we build on - is that
+the synchronous methods are the ones with the bang.  Similar to how mutating
 state is potentially dangerous and noted with a bang, using synchronous methods
 is potentially problematic for your users, and thus noted with a bang.
 
@@ -264,7 +282,9 @@ MyModel.reindex! # runs synchronously
 **Reindexing**  
 Calling `MyModel.reindex!` deletes all the existing records from the current index,
 and then reindexes all the records for the current model. It's safe to run this
-even if there aren't any records. 
+even if there aren't any records. In addition to re-indexing your models,
+it will update/set the "sortable" and "filterable" fields on the 
+relevant indexes.
 
 Note: reindexing behaves slightly differently than all the other methods.
 It runs semi-asynchronously by default. The Asynchronous form will first, 
@@ -303,6 +323,16 @@ Be careful to not add documents that are already in the index.
   WARNING: if you think you should use this, you're probably 
   mistaken. 
 
+#### Indexes 
+By default every model gets its own search index. This means that 
+`Foo.search("some text")` will only search `Foo` objects. To have a
+search cross objects you'll need to use a "Shared Index" (see below).
+
+
+The name of the index isn't important when not using shared indexes.
+By default a model's index is the snake cased form of the class name. 
+For example, data for `MyWidget` models will be stored in the `my_widget` index.
+
 #### Shared indexes
 Imagine you have a `Note` and a `Comment` model, sharing an index so that
 you can perform a single search and have search results for both models
@@ -422,10 +452,14 @@ To invoke any of Meilisearch's custom search options (see [their documentation](
 
 `MyModel.search("search term", options: <my custom options>)`
 
-The Meilisearch-ruby gem should be able to convert keys from snake case to 
+Currently the Meilisearch-ruby gem can convert keys from snake case to 
 camel case. For example `hits_per_page` will become `hitsPerPage`. 
-Meilisearch ultimately wants camel case. Follow their documentation 
-to see what's available and what type of options to pass it. Note that your 
+Meilisearch ultimately wants camel case (`camelCase`) parameter keys, 
+_but_ `meilisearch-ruby` wants snake case (`snake_case`). 
+
+Follow Meilisearch's documentation 
+to see what's available and what type of options to pass it, but convert 
+them to snake case first. Note that your 
 options keys and values must all be simple JSON values.
 
 If for some reason that still isn't enough, you can work with the 

data/lib/mongodb_meilisearch/version.rb

@@ -5,5 +5,5 @@ module MongodbMeilisearch
   # @note This library will adhere to strict semantic versioning.
   # See https://semver.org/
   #
-  VERSION = "1.0.1"
+  VERSION = "1.1.1"
 end

data/lib/search/class_methods.rb

@@ -109,6 +109,7 @@ module Search
     # @param filtered_by_class [Boolean] - defaults to filtering results by the class
     #        your searching from. Ex. Foo.search("something") it will
     #        have Meilisearch filter on records where `object_class` == `"Foo"`
+    #        This simplifies working with shared indexes.
     # @return [Hash[String, [Array[String | Document]] a hash with keys corresponding
     # to the classes of objects returned, and a value of an array of ids or
     # Mongoid::Document objects sorted by match strength. It will ALSO have a key named
@@ -135,13 +136,13 @@ module Search
 
       # TODO: break this if/else out into a separate function
       if ids_only
-        options.merge!({attributesToRetrieve: [pk.to_s]})
+        options.merge!({attributes_to_retrieve: [pk.to_s]})
       else
         # Don't care what you add, but we need the primary key and object_class
-        options[:attributesToRetrieve] = [] unless options.has_key?(:attributesToRetrieve)
+        options[:attributes_to_retrieve] = [] unless options.has_key?(:attributes_to_retrieve)
         [pk.to_s, "object_class"].each do |attr|
-          unless options[:attributesToRetrieve].include?(attr)
-            options[:attributesToRetrieve] << attr
+          unless options[:attributes_to_retrieve].include?(attr)
+            options[:attributes_to_retrieve] << attr
           end
         end
       end
@@ -260,6 +261,7 @@ module Search
     #    - each document hash is presumed to have been created by way of
     #      search_indexable_hash
     def add_documents(new_documents, async: true)
+      configure_attributes_and_index_if_needed!
       if async
         search_index.add_documents(new_documents, primary_search_key)
       else
@@ -378,28 +380,113 @@ module Search
     # @return [Array[Symbol]] an array of symbols corresponding to
     # filterable attribute names.
     def filterable_attributes
-      attributes = []
-      if constants.include?(:FILTERABLE_ATTRIBUTE_NAMES)
-        # the union operator is to guarantee no-one tries to create
-        # invalid filterable attributes
-        attributes = const_get(:FILTERABLE_ATTRIBUTE_NAMES).map(&:to_sym) & searchable_attributes
-      elsif !unfilterable?
-        attributes = searchable_attributes
+      @_filterable_attributes ||= sort_or_filter_attributes(:filterable)
+    end
+
+    def sortable_attributes
+      @_sortable_attributes ||= sort_or_filter_attributes(:sortable)
+    end
+
+    # For more details on sortable attributes see the official
+    # Meilisearch docs
+    # https://www.meilisearch.com/docs/reference/api/settings#sortable-attributes
+    #
+    #
+    # @return [Array] - an array of attributes configured as sortable
+    # in the index.
+    def meilisearch_sortable_attributes
+      @_meilisearch_sortable_attributes ||= search_index.get_sortable_attributes
+    end
+
+    def meilisearch_filterable_attributes
+      @_meilisearch_filterable_attributes ||= search_index.get_filterable_attributes
+    end
+
+    def reset_cached_data!
+      @_meilisearch_filterable_attributes = nil
+      @_filterable_attributes             = nil
+      @_meilisearch_sortable_attributes   = nil
+      @_sortable_attributes               = nil
+    end
+
+    # Guarantees that the filterable attributes have been configured
+    # This should be called before
+    def configure_attributes_and_index_if_needed!
+      return if unfilterable?
+      indexes_filterable_attributes = []
+
+      begin
+        indexes_filterable_attributes = meilisearch_filterable_attributes
+      rescue ::MeiliSearch::ApiError => e
+        # this is expected to happen the first time an instance
+        # of a new model is saved.
+        raise unless e.message.match?(/Index `\S+` not found\./)
+        Search::Client.instance.create_index(search_index_name)
       end
-      attributes << "object_class" unless attributes.include? "object_class"
-      attributes
+
+      return if indexes_filterable_attributes.include?("object_class")
+      set_filterable_attributes
+      set_sortable_attributes
     end
 
     # Updates the filterable attributes in the search index.
     # Note that this forces Meilisearch to rebuild your index,
     # which may take time. Best to run this in a background job
     # for large datasets.
-    def set_filterable_attributes!(new_attributes = filterable_attributes)
+    def set_filterable_attributes(new_attributes = filterable_attributes)
       search_index.update_filterable_attributes(new_attributes)
     end
 
+    def set_filterable_attributes!(new_attributes = filterable_attributes)
+      # meilisearch-ruby doesn't provide a synchronous version of this
+      task = set_filterable_attributes(new_attributes)
+      search_index.wait_for_task(task["taskUid"])
+    end
+
+    # Updates the sortable attributes in the search index.
+    # Note that this forces Meilisearch to rebuild your index,
+    # which may take time. Best to run this in a background job
+    # for large datasets.
+    def set_sortable_attributes(new_attributes = sortable_attributes)
+      search_index.update_sortable_attributes(new_attributes)
+    end
+
+    def set_sortable_attributes!(new_attributes = sortable_attributes)
+      # meilisearch-ruby doesn't provide a synchronous version of this
+      task = set_sortable_attributes(new_attributes)
+      search_index.wait_for_task(task["taskUid"])
+    end
+
     private
 
+    # @param [Symbol] which - either :sortable or :filterable
+    def sort_or_filter_attributes(which)
+      constant_symbol = (which == :sortable) ? :SORTABLE_ATTRIBUTE_NAMES : :FILTERABLE_ATTRIBUTE_NAMES
+
+      if which == :filterable && unfilterable? && constants.include?(constant_symbol)
+        raise "You can't define FILTERABLE_ATTRIBUTE_NAMES & UNFILTERABLE_IN_SEARCH on #{self.class.name}"
+      end
+      # with that out of the way...
+
+      attributes = []
+      # sortable == defined or filterable
+      # filterable == defined or search
+      if constants.include?(constant_symbol)
+        # the union operator is to guarantee no-one tries to create
+        # invalid filterable attributes
+        attributes = const_get(constant_symbol).map(&:to_sym) & searchable_attributes
+      elsif which == :filterable && !unfilterable?
+        attributes = searchable_attributes
+      elsif which == :sortable
+        # yes this is recursive...
+        attributes = filterable_attributes
+      end
+      # we need object_class even if you're unfilterable, because
+      # we need to be able to filter by object_class in shared indexes.
+      attributes << :object_class unless attributes.include? :object_class
+      attributes
+    end
+
     def lookup_matches_by_class!(results, primary_key)
       # matches_by_class contains a hash of
       # "FooModel" => [<array of ids>]
@@ -515,7 +602,7 @@ module Search
     def reindex_core(async: true)
       # no point in continuing if this fails...
       delete_all_documents!
-
+      reset_cached_data!
       # this conveniently lines up with the batch size of 100
       # that Mongoid gives us
       documents = []
@@ -528,7 +615,13 @@ module Search
       end
       add_documents(documents, async: async) if documents.size != 0
 
-      set_filterable_attributes!
+      if async
+        set_filterable_attributes
+        set_sortable_attributes
+      else
+        set_filterable_attributes!
+        set_sortable_attributes!
+      end
     end
   end
 end

data/lib/search/client.rb

@@ -30,7 +30,7 @@ module Search
       if @client.respond_to? m.to_sym
         @client.send(m, *args, &block)
       else
-        raise ArgumentError.new("Method `#{m}` doesn't exist.")
+        raise ArgumentError.new("Method `#{m}` doesn't exist in #{@client.inspect}.")
       end
     end
 

data/lib/search/instance_methods.rb

@@ -2,6 +2,7 @@ module Search
   module InstanceMethods
     # Adds this record to the search index asynchronously
     def add_to_search
+      self.class.configure_attributes_and_index_if_needed!
       search_index.add_documents(
         [search_indexable_hash],
         primary_search_key.to_s
@@ -10,6 +11,7 @@ module Search
 
     # Adds this record to the search index synchronously
     def add_to_search!
+      self.class.configure_attributes_and_index_if_needed!
       index     = search_index
       documents = [search_indexable_hash]
       pk        = primary_search_key.to_s

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongodb_meilisearch
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - masukomi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2023-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -187,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.17
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: MeiliSearch integration for MongoDB