mongodb_meilisearch 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d42d4314105bccabf3b1cc8dc49c1e7c578cc854d213f8fb73cde81aba26c03
-  data.tar.gz: 0dc187a25352ae68526a389d8e0deed4ba9772ff94a3a6fb2bf001e67f8ccbcb
+  metadata.gz: f57c18174244b2885536a990a2d602ce833e949dcf205112c78f30567a6eee6a
+  data.tar.gz: bb5bdd6c8cb90a6e1334c4606063a56b71515510f0f45c3e1ae2d817b4497163
 SHA512:
-  metadata.gz: 13f4ab53d0794010d49bcbdf325db757ceae92cbcce77c77c7dccc99fc4436312b9d786a79fe62609363a8f83372c025374f73cc967261cda231f9624b0e0672
-  data.tar.gz: ef36cb85710a0bcbe4c47747686aa19d0a7d6748000e4f8ed73e1682a01ec7c4166cffc7e0984faeb7d3b25f9c64288943a828888bcb161d24d2d2268ddf9974
+  metadata.gz: cb3e4f69dad6365682470020e3acc864492c45d79de54fb65fbab6fb9eaacb0811d8af02414f4df324a9d0cf64278646e0eac3062e7aff1a9873aa2f264d0d64
+  data.tar.gz: 54aa4eea1cfe0b378e9ad93c719eb31a5c35c96c08ef842d975efb8391cf1b55b0ca53e9ca3d8daf98626a02c30ea817e9623c78de0b6ce14ade726473767304

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.0)
       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, 

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.0"
 end

data/lib/search/class_methods.rb

@@ -378,28 +378,92 @@ 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
-      end
-      attributes << "object_class" unless attributes.include? "object_class"
-      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
+      # Search::Client.instance.http_get(
+      search_index.http_get(
+        "/indexes/#{search_index}/settings/sortable-attributes"
+      )
+    end
+
+    def meilisearch_filterable_attributes
+      # Search::Client.instance.http_get(
+      search_index.http_get(
+        "/indexes/#{search_index}/settings/filterable-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>]
@@ -528,7 +592,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongodb_meilisearch
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - masukomi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2023-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails