refine-rails 2.9.0

data/app/models/refine/tracks_pending_relationship_subqueries.rb

@@ -0,0 +1,196 @@
+module Refine
+  module TracksPendingRelationshipSubqueries
+    def pending_relationship_subquery_depth
+      @pending_relationship_subquery_depth ||= []
+    end
+
+    def pending_relationship_subqueries
+      # The Hash.new block will dynamically created multi-level nested keys
+      # Note: Will create a value of {} when accessed with `dig`
+      @pending_relationship_subqueries ||= Hash.new { |h, k| h[k] = h.dup.clear }
+    end
+
+    # Allow filter refinements to be collapsable in order to slot them in a the appropriate depth
+    def allow_pending_relationship_to_collapse
+      pending_relationship_subqueries.dig(*get_current_relationship)[:collapsible] = true
+    end
+
+    def set_pending_relationship(relation, instance)
+      pending_relationship_subquery_depth << relation.to_sym
+      # this populates modelA[:children][:modelB]
+      pending_relationship_subqueries.dig(*get_current_relationship)[:instance] = instance
+    end
+
+    def get_current_relationship
+      pending_relationship_subquery_depth.join(".children.").split(".").map(&:to_sym)
+    end
+
+    def add_pending_joins_relationship_subquery(subquery:)
+      add_pending_relationship_subquery(subquery: subquery, primary_key: JOINS)
+    end
+
+    def add_pending_relationship_subquery(subquery:, primary_key:, secondary_key: nil, inverse_clause: false)
+      # Add key, query, and secondary keys at the correct depth
+      pending_relationship_subqueries.dig(*get_current_relationship)[:key] = primary_key
+      pending_relationship_subqueries.dig(*get_current_relationship)[:query] = subquery
+      pending_relationship_subqueries.dig(*get_current_relationship)[:secondary] = secondary_key
+      pending_relationship_subqueries.dig(*get_current_relationship)[:inverse_clause] = inverse_clause
+    end
+
+    def get_pending_relationship_instance
+      get_pending_relationship_item("instance")
+    end
+
+    def get_pending_relationship_item(key)
+      # Digging for a particular key will create a {} value, must check presence.
+      if pending_relationship_subqueries.dig(*get_current_relationship, key.to_sym).present?
+        pending_relationship_subqueries.dig(*get_current_relationship, key.to_sym)
+      else
+        nil
+      end
+    end
+
+    def set_pending_relationship_subquery_wrapper(callback)
+      pending_relationship_subqueries.dig(*get_current_relationship)[:wrapper] = callback
+    end
+
+    def relationship_supports_collapsing(instance)
+      if get_current_relationship.present?
+        return true if pending_relationship_subqueries.dig(*get_current_relationship)[:collapsible] == true
+      end
+
+      (instance.is_a? ActiveRecord::Reflection::BelongsToReflection) || (instance.is_a? ActiveRecord::Reflection::HasOneReflection)
+    end
+
+    # This method can be challenging to understand. Walk through the values with the `can handle nested relationships` test.
+    # The query will eventually return the following SQL:
+    #     SELECT "btt_phones".* FROM "btt_phones"
+    #     WHERE ("btt_phones"."btt_user_id" IN
+    #     (SELECT "btt_users"."id" FROM "btt_users" WHERE "btt_users"."id" IN
+    #     (SELECT "btt_notes"."btt_user_id" FROM "btt_notes" WHERE ("btt_notes"."body" LIKE \'%foo%\'))))
+
+    def release_pending_relationship
+      # instance is the ActiveRecord::Reflection::HasManyReflection between btt_notes and BttUser
+      instance = get_pending_relationship_instance
+      # Pop off the last key (last relationship)
+      # popped = :btt_notes
+      popped = pending_relationship_subquery_depth.pop.to_sym
+      return if relationship_supports_collapsing(instance)
+      # current = [:btt_user]
+      current = get_current_relationship
+      if current.blank?
+        @immediately_commit_pending_relationship_subqueries = true
+        return
+      end
+      # Grab the query one level higher than the current stack (removed during pop)
+      # query is the pending_relationship_subqueries[:btt_user][:query] = "SELECT `btt_users`.`id` FROM `btt_users`"
+      query = pending_relationship_subqueries.dig(*current)[:query]
+      # Build hash to send to commit_subset with popped -> value at popped
+      subset = {}
+      # subset is a hash with key [:btt_notes] (the popped relationship) = value at popped.
+      # subset[:btt_notes].keys = [:instance, :query, :key, :secondary, :inverse_clause]
+      #  subset[:btt_notes][:query].to_sql
+      # "SELECT `btt_notes`.`btt_user_id` FROM `btt_notes` WHERE (`btt_notes`.`body` LIKE '%foo%')"
+
+      subset[popped] = pending_relationship_subqueries.dig(*current)[:children][popped]
+      # Remove popped from pending relationships subqueries -> handled in commit_subset
+      # We are removing the "child" relationship we just set to subset (in this case :btt_notes)
+      # pending_relationship_subqueries[:btt_user][:children] = {}
+      # And assigning the value at [:btt_user][:query] to what is returned in commit_subset
+      pending_relationship_subqueries.dig(*current)[:children].except!(popped)
+      # query is the high level linking query = "SELECT `btt_users`.`id` FROM `btt_users`"
+      # and subset is the hash of the child relationship we just removed from pending_relationship_subqueries
+      # subset[:btt_notes].keys = [:instance, :query, :key, :secondary, :inverse_clause]
+      pending_relationship_subqueries.dig(*current)[:query] = commit_subset(subset: subset, query: query)
+    end
+
+    def commit_pending_relationship_subqueries
+      applied_query = commit_subset(subset: pending_relationship_subqueries)
+      @pending_relationship_subqueries = Hash.new { |h, k| h[k] = h.dup.clear }
+      applied_query
+    end
+
+    def commit_subset(subset:, query: nil)
+      # Turn pending relationship subqueries into nodes to apply
+      # Subquery below is the hash value which has a query key.
+      subset.each do |relation, subquery|
+        # relation = table
+        # subquery.keys = [:instance, :query, :key, :secondary] possibly (:children)
+        if subquery.dig(:children).present?
+          # Send in the values at children as the subset hash and remove from existing subquery
+          child_nodes = subquery.delete(:children)
+          # If there are children, we recursively call this method again
+          # to build up the inner (child) queries first. This allows us
+          # to intelligently nest multiple levels of relationships.
+          commit_subset(query: subquery[:query], subset: child_nodes)
+        end
+        # If the subquery has a wrapper proc we are dealing with a compare to 0 situation
+        if subquery.dig(:wrapper).respond_to? :call
+          subquery[:query] = subquery[:wrapper].call(subquery[:query], subquery[:key], subquery[:secondary])
+        end
+
+        parent_table = subquery[:instance].active_record.arel_table
+        linking_key = subquery[:key]
+        inner_query = subquery[:query]
+
+        # Compare database connections for inner and outer query. Refer to ActiveRecord::Reflection
+        # Example: 
+        # class Company < ActiveRecord::Base
+        #   has_many :clients
+        # end
+
+        # Company.reflect_on_association(:clients).klass
+        # # => Client
+
+        # If the query needs to be flipped because it's a negative do that here 
+        connecting_method = subquery[:inverse_clause] ? :not_in : :in
+
+        current_model = subquery[:instance]&.klass 
+        parent_model = subquery[:instance]&.active_record
+        use_multiple_databases = (inner_query.is_a? Arel::SelectManager) && use_multiple_databases?(current_model, parent_model)
+        if query.present?
+          # If query exists and is a Select Manager we are deeply nested and need to build the query
+          # with a WHERE statement
+          if query.is_a? Arel::SelectManager
+            if use_multiple_databases
+              array_of_ids = current_model.connection.exec_query(inner_query.to_sql).rows.flatten
+              query.where(parent_table[linking_key.to_s].in(array_of_ids))
+            else
+              # Same DB, don’t decompose. Note: Where’s called on AREL select managers modify the object in place
+              query.where(parent_table[linking_key.to_s].in(inner_query))
+            end
+          else
+            # Otherwise we are joining nodes, which requires an AND statement (ORs are immediately commited)
+            # query can be a `Arel::Nodes::In` class (See HMMT test for example)
+            # The group() in front of query is required for nested relationship attributes.
+            if use_multiple_databases
+              array_of_ids = current_model.connection.exec_query(inner_query.to_sql).rows.flatten
+              query = group(query).and(group(parent_table[linking_key.to_s].in(array_of_ids)))
+            else
+              query = group(query).and(group(parent_table[linking_key.to_s].in(inner_query)))
+            end
+            # query = group(query).and(group(parent_table[linking_key.to_s].in(inner_query)))
+          end
+        else
+          # No existing query, top level of stack 
+          if use_multiple_databases
+            array_of_ids = current_model.connection.exec_query(inner_query.to_sql).rows.flatten
+            query = parent_table[linking_key.to_s].send(connecting_method, array_of_ids.uniq)
+          else
+            query = parent_table[linking_key.to_s].send(connecting_method, inner_query)
+          end
+        end
+      end
+      query
+    end
+
+    def use_multiple_databases?(current_model, parent_model)
+      # Are the queries on different databases?
+      parent_model.connection_db_config.configuration_hash != current_model.connection_db_config.configuration_hash
+    end
+
+    def get_pending_relationship_subquery
+      get_pending_relationship_item("query")
+    end
+  end
+end

data/app/views/_filter_builder_dropdown.html.erb

@@ -0,0 +1,63 @@
+<%
+  unless defined? stored_filters
+    stored_filters = false
+  end
+%>
+  <div
+  data-controller="refine--search-filter"
+   data-refine--search-filter-search-frame-id-value="index_search"
+   data-refine--search-filter-submit-url-value="<%= refine_blueprint_path %>"
+   data-action="filter-submit-success@document->refine--search-filter#loadResults"
+  >
+
+  <%= tag.div class: "refine-filter-builder-dropdown-container", data: {
+    controller: "refine--toggle"
+  } do %>
+    <button
+      class="refine-filter-condition-toggle-button"
+      data-action="refine--toggle#toggle"
+      type="button"
+    >
+      <%= t('global.buttons.filter') %>
+    </button>
+    <div
+      hidden
+      data-refine--toggle-target="content"
+      data-reveal
+      data-transition
+      data-transition-enter="transition ease-out duration-100"
+      data-transition-enter-start="transform opacity-0 scale-95"
+      data-transition-enter-end="transform opacity-100 scale-100"
+      data-transition-leave="transition ease-in duration-75"
+      data-transition-leave-start="transform opacity-100 scale-100"
+      data-transition-leave-end="transform opacity-0 scale-95"
+      data-controller="filter-link"
+
+      class="refine-filter-builder-dropdown-search-box"
+      style="min-width: 50vw; max-height: 66vh; overflow: auto;"
+    >
+      <%= turbo_frame_tag :refine_filter_modal, loading: :lazy,
+        src: new_refine_blueprint_path(refine_filters_builder: {stable_id: @stable_id, filter_class: @refine_filter.class.name}, stored_filters: stored_filters.presence) do %>
+
+      <% end %>
+      <div class="refine-filter-builder-dropdown-button-container">
+        <button
+          class="refine-filter-builder-dropdown-cancel-button"
+          data-action="click->refine--toggle#toggle"
+          type="button"
+        >
+          <%= t('global.buttons.cancel') %>
+        </button>
+        <button
+          class="refine-filter-builder-dropdown-apply-button"
+          data-action="click->refine--search-filter#search"
+          data-filter-link-target="link"
+          type="button"
+        >
+          <%= t('global.buttons.apply') %>
+        </button>
+      </div>
+    </div>
+  <% end %>
+
+</div>

data/app/views/_filter_pills.html.erb

@@ -0,0 +1,40 @@
+<% if @refine_filter %>
+  <%= tag.div id: dom_id(@refine_filter_builder, "query"),
+              data: {
+                controller: "refine--filter-pills refine--state turbo-visit",
+                refine__state_conditions_value: @refine_filter_query.available_conditions_attributes.to_json,
+                refine__state_blueprint_value: @refine_filter_builder.blueprint.to_json,
+                refine__state_class_name_value: @refine_filter_query.configuration[:class_name],
+                refine__state_refresh_url_value: refine_blueprint_path,
+                refine__state_client_id_value: @refine_filter_builder.client_id,
+                refine__filter_pills_submit_url_value: refine_blueprint_path,
+                action: "filter-submit-success->turbo-visit#visit"
+              } do
+  %>
+
+    <% if @refine_filter.human_readable_criterions.any? %>
+      <div class="text-blue-600 pb-3 font-medium text-sm rounded w-full">
+        <div class="w-full flex pb-1 refine-filter-condition-pills-wrapper">
+          <div class="refine-filter-conditions-wrapper-icon"></div>
+          <% @refine_filter.human_readable_criterions.each_with_index do |condition, index| %>
+
+            <% if ["or", "and"].include?(condition) %>
+              <span class="refine-filter-condition-pill-and"><%=  t(".pill_and.#{condition}") %></span>
+            <% else %>
+              <% data_action = "click->refine--filter-pills#delete" %>
+              <div class="refine-filter-condition-pill">
+                <%= condition %>
+                <button
+                  class="refine-filter-remove-condition-pill"
+                  data-action="<%= data_action %>"
+                  data-criterion-id="<%= index %>"
+                >
+                </button>
+              </div>
+            <% end %>
+          <% end %>
+        </div>
+      </div>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/_loading.html.erb

@@ -0,0 +1,32 @@
+<%
+  style ||= ""
+
+  case style
+  when "tr"
+    classes = "rounded-sm p-1 w-full mx-auto mt-0"
+    spacing = "2"
+    rows = 1
+  when "large"
+    classes = "rounded-md shadow p-12 w-full mx-auto mt-6"
+    spacing = "6"
+    rows = 5
+  else
+    classes = "rounded-sm shadow-sm p-4 w-full mx-auto mt-4"
+    spacing = "4"
+    rows = 3
+  end
+%>
+<div class="<%= classes %>">
+  <div class="animate-pulse flex space-x-<%= spacing %>">
+    <div class="rounded-full bg-gray-400 h-12 w-12"></div>
+    <div class="flex-1 space-y-<%= spacing %> py-1">
+      <div class="h-4 bg-gray-400 rounded w-3/4"></div>
+      <div class="space-y-<%= spacing.to_i / 2 %>">
+        <% rows.times do %>
+          <div class="h-4 bg-gray-400 rounded"></div>
+        <% end %>
+          <div class="h-4 bg-gray-400 rounded w-5/6"></div>
+      </div>
+    </div>
+  </div>
+</div>

data/app/views/refine/blueprints/_add_and.html.erb

@@ -0,0 +1,25 @@
+<% 
+  is_disabled = @refine_filter_builder.refine_filter.criteria_limit_reached?
+  criteria_limit = @refine_filter_builder.refine_filter.criteria_limit
+%>
+
+<%= tag.div(
+  class: "refine-add-container",
+  data: {
+    controller: 'refine--add',
+    refine__add_previous_criterion_id_value: (criteria.last.position unless is_disabled)
+  }) do %>
+
+  <%= tag.div(
+    class: class_names(
+      "refine-add-and" => true,
+      "refine-add-disabled" => is_disabled
+    ),
+    style: "transition: all .15s ease",
+    data: {action: ("click->refine--add#criterion" unless is_disabled)},
+    title: (t("refine.inline.filters.criteria_limit", criteria_limit: criteria_limit) if is_disabled)
+
+  ) do %>
+    <span class="refine-add-button-text"><%= t("refine.refine_blueprints.add_and.add_and") %></span><i class="refine-add-icon fal fa-plus"></i>
+  <% end %>
+<% end %>

data/app/views/refine/blueprints/_add_group.html.erb

@@ -0,0 +1,24 @@
+<% 
+  is_disabled = @refine_filter_builder.refine_filter.criteria_limit_reached?
+  criteria_limit = @refine_filter_builder.refine_filter.criteria_limit
+%>
+
+<%= tag.div(
+  class: "refine-add-container",
+  data: {controller: 'refine--add'}) do %>
+
+  <%= tag.div(
+    class: class_names(
+      "refine-add-group" => true,
+      "refine-add-disabled" => is_disabled
+    ),
+    data: {action: ("click->refine--add#group" unless is_disabled)},
+    title: (t("refine.inline.filters.criteria_limit", criteria_limit: criteria_limit) if is_disabled)
+  ) do %>
+    <% if @refine_filter_query.grouped_criteria.any? %>
+      <%= t("refine.refine_blueprints.add_group.add_or") %>
+    <% else %>
+      <%= t("refine.refine_blueprints.add_group.create_filter") %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/refine/blueprints/_clause_select.html.erb

@@ -0,0 +1,24 @@
+<% prefixedClass = 'refine-clause-select-prefixed' if meta[:prefix] %>
+<%= tag.div class: prefixedClass, data: {
+  action: "$change->refine--update#clause",
+  controller: 'fields--super-select',
+  fields__super_select_enable_search_value: 'true',
+  fields__super_select_container_width_value: 'resolve',
+} do %>
+  <% if meta[:prefix] %>
+    <span class="refine-clause-select-prefix"><%= meta[:prefix] %></span>
+  <% end %>
+  <select
+    data-fields--super-select-target="select"
+    data-input-id='<%= input_id if defined? input_id %>'
+    name="clauses"
+    class="refine-clause-select"
+  >
+    <% meta[:clauses].each do |clause| %>
+      <option
+        value="<%= clause[:id] %>"
+        <% if selected_clause == clause[:id] %>selected<% end %>
+      ><%= clause[:display] %></option>
+    <% end %>
+  </select>
+<% end %>

data/app/views/refine/blueprints/_condition_select.html.erb

@@ -0,0 +1,53 @@
+<%
+  conditions = @refine_filter_query.available_conditions_attributes
+
+  conditions_for_category = -> (category) do
+    conditions.filter { |c| c[:meta][:category] == category}
+  end
+
+  categories = conditions.map { |c| c[:meta][:category] }.uniq.compact
+
+  # Note that the stimulus controllers set default condition id for new conditions
+  # so this is only for rare cases where it gets unset
+  selected_condition_id ||= @refine_filter.default_condition_id
+  selected_condition_id ||= categories
+    .first
+    &.conditions_for_category.call(categories.first)
+    [:id]
+
+  uncategorized_conditions = conditions.filter { |c| c[:meta][:category].nil? }
+
+%>
+
+<%= tag.div data: {
+  action: "$change->refine--update#condition",
+  controller: 'fields--super-select',
+  fields__super_select_enable_search_value: 'true',
+  fields__super_select_container_width_value: 'resolve',
+} do %>
+  <select
+    data-fields--super-select-target="select"
+    data-condition-id="<%= selected_condition_id %>"
+    name="conditions"
+    class="refine-condition-select"
+  >
+    <optgroup >
+      <% uncategorized_conditions.each do |condition_option| %>
+        <option
+          value="<%= condition_option[:id] %>"
+          <% if selected_condition_id == condition_option[:id] %>selected<% end %>
+        ><%= condition_option[:display] %></option>
+      <% end %>
+    </optgroup>
+    <% categories.each do |category| %>
+      <optgroup class="divider" label="<%= category %>">
+        <% conditions_for_category.call(category).each do |condition_option| %>
+          <option
+            value="<%= condition_option[:id] %>"
+            <% if selected_condition_id == condition_option[:id] %>selected<% end %>
+          ><%= condition_option[:display] %></option>
+        <% end %>
+      </optgroup>
+    <% end %>
+  </select>
+<% end %>

data/app/views/refine/blueprints/_criterion.html.erb

@@ -0,0 +1,41 @@
+<% criterion_id = criterion.position %>
+
+<%= tag.div(class: 'refine-criterion-container', data: {
+  controller: 'refine--update',
+  refine__update_criterion_id_value: criterion_id,
+  position: criterion.position}) do %>
+
+  <!-- Select Condition -->
+  <div class="refine-criterion-condition-container">
+    <%= render partial: 'refine/blueprints/condition_select', locals: {
+      selected_condition_id: criterion.condition_id } %>
+  </div>
+
+  <!-- Select Clause -->
+  <div class="refine-criterion-clause-container">
+    <%= render partial: 'refine/blueprints/clause_select', locals: {
+        meta: criterion.meta, selected_clause: criterion.input[:clause]} %>
+  </div>
+
+  <!-- Render correct type of condition -->
+  <%= render partial: "refine/blueprints/clauses/#{criterion.component}", locals: {
+    criterion: criterion,
+    condition: criterion.condition, input: criterion.input, criterion_id: criterion_id, meta: criterion.meta, meta_clause: criterion.selected_clause_meta, input_id: nil } %>
+
+  <!-- Refinements -->
+  <% criterion.refinements.each do |refinement|%>
+
+    <div class="refine-criterion-refinement-container">
+      <%= render partial: 'refine/blueprints/clause_select', locals: {
+        meta: refinement[:meta], input_id: "input, #{refinement[:id]}", selected_clause: criterion.input.dig(:input, refinement[:id].to_sym, :clause) || {} } %>
+    </div>
+
+    <%= render partial: "refine/blueprints/clauses/#{refinement[:component].underscore}", locals: {
+      condition: refinement, input: criterion.input[refinement[:id].to_sym] || {}, criterion_id: criterion_id, meta: refinement[:meta], input_id: "input, #{refinement[:id]}", meta_clause: criterion.meta_for_refinement_clause(refinement), criterion: criterion} %>
+  <% end %>
+  <!-- End Refinements -->
+
+<% end %>
+
+<%= render 'refine/blueprints/delete_criterion', criterion_id: criterion_id %>
+

data/app/views/refine/blueprints/_criterion_errors.html.erb

@@ -0,0 +1,7 @@
+<% if criterion.errors.any? %>
+  <% criterion.errors.each do |error| %>
+  <p class="refine-criterion-error">
+    <%= error.full_message %>
+  </p>
+  <% end %>
+<% end %>

data/app/views/refine/blueprints/_delete_criterion.html.erb

@@ -0,0 +1,11 @@
+<%= tag.div class: 'refine-delete-container', data: {
+  controller: 'refine--delete',
+  refine__delete_criterion_id_value: criterion_id,
+} do %>
+  <%= button_tag type: 'button', class: 'refine-delete-button', data: {
+    action: "click->refine--delete#criterion",
+  } do %>
+    <i class="refine-delete-criterion-icon ti ti-trash"></i>
+    <span class="refine-delete-criterion-label"><%= t("refine.refine_blueprints.query.buttons.remove_filter") %></span>
+  <% end %>
+<% end %>

data/app/views/refine/blueprints/_group.html.erb

@@ -0,0 +1,13 @@
+<%= tag.div id: dom_id(@refine_filter_builder, "group_#{group_id}") do %>
+  <div class="refine-group-container">
+    <% criteria&.each_with_index do |criterion, index| %>
+      <div class="refine-group-criterion-container">
+        <%= render "refine/blueprints/criterion", criterion: criterion %>
+      </div>
+      <% if criteria.count > 1 && index < criteria.count - 1 %>
+        <p class="refine-group-and"><%= t("refine.refine_blueprints.add_and.add_and") %></p>
+      <% end %>
+    <% end %>
+    <%= render 'refine/blueprints/add_and', criteria: criteria %>
+  </div>
+<% end %>

data/app/views/refine/blueprints/_query.html.erb

@@ -0,0 +1,34 @@
+<%= tag.div id: dom_id(@refine_filter_builder, "query"), class: 'refine-query-container', data: {
+  controller: "refine--state",
+  refine__state_conditions_value: @refine_filter_query.available_conditions_attributes.to_json,
+  refine__state_blueprint_value: @refine_filter_query.blueprint.to_json,
+  refine__state_class_name_value: @refine_filter_query.configuration[:class_name],
+  refine__state_refresh_url_value: refine_blueprint_path,
+  refine__state_client_id_value: @refine_filter_builder.client_id,
+  refine__state_default_condition_id_value: @refine_filter_query.filter.default_condition_id,
+  refine__state_validate_blueprint_url_value: validate_refine_blueprint_path } do %>
+  <%= content_tag :div, class: "refine-query-content-container" do %>
+    <div
+      class="refine-query-loading-container <%= "hidden" unless action_name == "create" %>"
+      id="refine-loader"
+      data-refine--state-target="loading">
+      <p class="refine-query-loading-text"><%= t("refine.refine_blueprints.query.loading") %></p>
+    </div>
+
+    <%= tag.div id: dom_id(@refine_filter_builder, "groups") do %>
+      <% @refine_filter_query.grouped_criteria.each_with_index do |criteria, index| %>
+        <% if index > 0 %>
+          <p class="refine-query-or"><%= t("refine.refine_blueprints.query.query_or") %></p>
+        <% end %>
+        <%= render partial: 'refine/blueprints/group', locals: {
+          criteria: criteria,
+          group_id: index }
+        %>
+      <% end %>
+
+    <% end %>
+
+    <%= render 'refine/blueprints/add_group' %>
+  <% end %>
+<% end %>
+

data/app/views/refine/blueprints/_stored_filters.html.erb

@@ -0,0 +1,23 @@
+<%= turbo_frame_tag "stored_filters" do %>
+  <%= content_tag :div, class: "refine-stored-filter-head-container" do %>
+   <h3
+      class="refine-stored-filter-header"
+    >
+      <%= @stored_filter&.name || t("global.buttons.filter") %>
+    </h3>
+    <a
+      href="<%= refine_stored_filters_path(@refine_filter_builder.to_params) %>"
+      class="refine-stored-filter-link"
+    >
+      <%= t('global.buttons.find_filter') %>
+    </a>
+    <span class="text-xs ml-4 mr-4 leading-6">
+      <a
+        class="text-blue-600 background-transparent font-bold underline outline-none focus:outline-none"
+        href="<%= new_refine_stored_filter_path(@refine_filter_builder.to_params) %>"
+      >
+        <%= t('global.buttons.save_filter') %>
+      </a>
+    </span>
+  <% end %>
+<% end %>