avo 2.53.0 → 3.0.0.beta1

data/app/controllers/avo/base_controller.rb

@@ -6,14 +6,13 @@ module Avo
 
     before_action :set_resource_name
     before_action :set_resource
-    before_action :hydrate_resource
     before_action :set_applied_filters, only: :index
-    before_action :set_model, only: [:show, :edit, :destroy, :update, :order]
-    before_action :set_model_to_fill
+    before_action :set_record, only: [:show, :edit, :destroy, :update, :preview]
+    before_action :set_record_to_fill
     before_action :set_edit_title_and_breadcrumbs, only: [:edit, :update]
-    before_action :fill_model, only: [:create, :update]
+    before_action :fill_record, only: [:create, :update]
     # Don't run base authorizations for associations
-    before_action :authorize_base_action, if: -> { controller_name != "associations" }
+    before_action :authorize_base_action, except: :preview, if: -> { controller_name != "associations" }
     before_action :set_pagy_locale, only: :index
 
     def index
@@ -29,11 +28,6 @@ module Avo
         @query = @resource.class.query_scope
       end
 
-      # Remove default_scope for index view if no parent_resource present
-      if @resource.unscoped_queries_on_index && @parent_resource.blank?
-        @query = @query.unscoped
-      end
-
       # Eager load the associations
       if @resource.includes.present?
         @query = @query.includes(*@resource.includes)
@@ -48,18 +42,13 @@ module Avo
           @query = @query.unscope(:order)
         end
 
-        sanitized_sort_direction = @index_params[:sort_direction].presence_in(["asc", "desc"])
-
         # Check if the sortable field option is actually a proc and we need to do a custom sort
-        sort_by = @index_params[:sort_by].to_sym
-        field = @resource.get_field(sort_by)
+        field_id = @index_params[:sort_by].to_sym
+        field = @resource.get_field_definitions.find { |field| field.id == field_id }
         @query = if field&.sortable.is_a?(Proc)
-          field.sortable.call(@query, sanitized_sort_direction)
-        elsif field.present? && sanitized_sort_direction
-          @query.order("#{@resource.model_class.table_name}.#{sort_by} #{sanitized_sort_direction}")
-        # Transform Model to ActiveRecord::Relation because Avo expects one.
+          Avo::ExecutionContext.new(target: field.sortable, query: @query, direction: @index_params[:sort_direction]).handle
         else
-          @query.where("1=1")
+          @query.order("#{@resource.model_class.table_name}.#{@index_params[:sort_by]} #{@index_params[:sort_direction]}")
         end
       end
 
@@ -70,57 +59,62 @@ module Avo
         ).apply_query request, @query, filter_value
       end
 
-      apply_pagination
+      extra_pagy_params = {}
+
+      # Reset open filters when a user navigates to a new page
+      extra_pagy_params[:keep_filters_panel_open] = if params[:keep_filters_panel_open] == "1"
+        "0"
+      end
+
+      safe_call :set_and_apply_scopes
+      safe_call :apply_dynamic_filters
 
-      # Create resources for each model
-      @resources = @models.map do |model|
-        @resource.hydrate(model: model, params: params).dup
+      @pagy, @records = pagy(pagy_query, items: @index_params[:per_page], link_extra: "data-turbo-frame=\"#{params[:turbo_frame]}\"", size: [1, 2, 2, 1], params: extra_pagy_params)
+
+      # Create resources for each record
+      @resources = @records.map do |record|
+        @resource.hydrate(record: record, params: params).dup
       end
     end
 
     def show
-      @resource.hydrate(model: @model, view: :show, user: _current_user, params: params)
+      @resource.hydrate(record: @record, view: :show, user: _current_user, params: params).detect_fields
 
       set_actions
 
       @page_title = @resource.default_panel_name.to_s
 
       # If we're accessing this resource via another resource add the parent to the breadcrumbs.
-      if params[:via_resource_class].present? && params[:via_resource_id].present?
-        via_resource = Avo::App.get_resource(params[:via_resource_class]).dup
-        via_model = via_resource.find_record params[:via_resource_id], params: params
-        via_resource.hydrate model: via_model
+      if params[:via_resource_class].present? && params[:via_record_id].present?
+        via_resource = Avo.resource_manager.get_resource(params[:via_resource_class])
+        via_record = via_resource.find_record params[:via_record_id], params: params
+        via_resource = via_resource.new record: via_record
 
         add_breadcrumb via_resource.plural_name, resources_path(resource: via_resource)
-        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource)
+        add_breadcrumb via_resource.record_title, resource_path(record: via_record, resource: via_resource)
       else
         add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
       end
 
-      add_breadcrumb @resource.model_title
+      add_breadcrumb @resource.record_title
       add_breadcrumb I18n.t("avo.details").upcase_first
     end
 
     def new
-      @model = @resource.model_class.new
-      @resource = @resource.hydrate(model: @model, view: :new, user: _current_user)
-
-      # Handle special cases when creating a new record via a belongs_to relationship
-      if params[:via_belongs_to_resource_class].present?
-        return render turbo_stream: turbo_stream.append('attach_modal', partial: 'avo/base/new_via_belongs_to')
-      end
+      @record = @resource.model_class.new
+      @resource = @resource.hydrate(record: @record, view: :new, user: _current_user)
 
       set_actions
 
       @page_title = @resource.default_panel_name.to_s
 
       if is_associated_record?
-        via_resource = Avo::App.get_resource_by_model_name(params[:via_relation_class]).dup
-        via_model = via_resource.find_record params[:via_resource_id], params: params
-        via_resource.hydrate model: via_model
+        via_resource = Avo.resource_manager.get_resource_by_model_class(params[:via_relation_class])
+        via_record = via_resource.find_record params[:via_record_id], params: params
+        via_resource = via_resource.new record: via_record
 
         add_breadcrumb via_resource.plural_name, resources_path(resource: via_resource)
-        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource)
+        add_breadcrumb via_resource.record_title, resource_path(record: via_record, resource: via_resource)
       end
 
       add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
@@ -128,37 +122,37 @@ module Avo
     end
 
     def create
-      # model gets instantiated and filled in the fill_model method
-      saved = save_model
-      @resource.hydrate(model: @model, view: :new, user: _current_user)
+      # record gets instantiated and filled in the fill_record method
+      saved = save_record
+      @resource.hydrate(record: @record, view: :new, user: _current_user)
 
       # This means that the record has been created through another parent record and we need to attach it somehow.
-      if params[:via_resource_id].present? && params[:via_belongs_to_resource_class].nil?
-        @reflection = @model.class.reflect_on_association(params[:via_relation])
+      if params[:via_record_id].present?
+        @reflection = @record._reflections[params[:via_relation]]
         # Figure out what kind of association does the record have with the parent record
 
         # Fills in the required infor for belongs_to and has_many
         # Get the foreign key and set it to the id we received in the params
         if @reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection) || @reflection.is_a?(ActiveRecord::Reflection::HasManyReflection)
-          related_resource = Avo::App.get_resource_by_model_name params[:via_relation_class]
-          related_record = related_resource.find_record params[:via_resource_id], params: params
+          related_resource = Avo.resource_manager.get_resource_by_model_class params[:via_relation_class]
+          related_record = related_resource.find_record params[:via_record_id], params: params
 
-          @model.send("#{@reflection.foreign_key}=", related_record.id)
-          @model.save
+          @record.send("#{@reflection.foreign_key}=", related_record.id)
+          @record.save
         end
 
         # For when working with has_one, has_one_through, has_many_through, has_and_belongs_to_many, polymorphic
-        if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection) || @reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+        if @reflection.is_a? ActiveRecord::Reflection::ThroughReflection
           # find the record
-          via_resource = ::Avo::App.get_resource_by_model_name(params[:via_relation_class]).dup
-          @related_record = via_resource.find_record params[:via_resource_id], params: params
-          association_name = BaseResource.valid_association_name(@model, params[:via_relation])
+          via_resource = Avo.resource_manager.get_resource_by_model_class(params[:via_relation_class])
+          @related_record = via_resource.find_record params[:via_record_id], params: params
+          association_name = BaseResource.valid_association_name(@record, params[:via_relation])
 
           if params[:via_association_type] == "has_one"
             # On has_one scenarios we should switch the @record and @related_record
-            @related_record.send("#{@reflection.parent_reflection.inverse_of.name}=", @model)
+            @related_record.send("#{@reflection.parent_reflection.inverse_of.name}=", @record)
           else
-            @model.send(association_name) << @related_record
+            @record.send(association_name) << @related_record
           end
         end
       end
@@ -179,9 +173,9 @@ module Avo
     end
 
     def update
-      # model gets instantiated and filled in the fill_model method
-      saved = save_model
-      @resource = @resource.hydrate(model: @model, view: :edit, user: _current_user)
+      # record gets instantiated and filled in the fill_record method
+      saved = save_record
+      @resource = @resource.hydrate(record: @record, view: :edit, user: _current_user)
       set_actions
 
       if saved
@@ -199,55 +193,46 @@ module Avo
       end
     end
 
-    def order
-      direction = params[:direction].to_sym
+    def preview
+      @resource.hydrate(record: @record, view: :show, user: _current_user, params: params)
 
-      if direction.present?
-        @resource
-          .hydrate(model: @model, params: params)
-          .ordering_host
-          .order direction
-      end
-
-      respond_to do |format|
-        format.html { redirect_to params[:referrer] || resources_path(resource: @resource) }
-      end
+      render layout: params[:turbo_frame].blank?
     end
 
     private
 
-    def save_model
+    def save_record
       perform_action_and_record_errors do
-        save_model_action
+        save_record_action
       end
     end
 
-    def save_model_action
-      @model.save!
+    def save_record_action
+      @record.save!
     end
 
     def destroy_model
       perform_action_and_record_errors do
-        destroy_model_action
+        destroy_record_action
       end
     end
 
-    def destroy_model_action
-      @model.destroy!
+    def destroy_record_action
+      @record.destroy!
     end
 
     def perform_action_and_record_errors(&block)
       begin
         succeeded = block.call
       rescue => exception
-        # In case there's an error somewhere else than the model
+        # In case there's an error somewhere else than the record
         # Example: When you save a license that should create a user for it and creating that user throws and error.
         # Example: When you Try to delete a record and has a foreign key constraint.
         exception_message = exception.message
       end
 
-      # Add the errors from the model
-      @errors = @model.errors.full_messages.reject { |error| exception_message.include? error }.unshift exception_message
+      # Add the errors from the record
+      @errors = @record.errors.full_messages.reject { |error| exception_message.include? error }.unshift exception_message
 
       succeeded
     end
@@ -305,7 +290,7 @@ module Avo
         @index_params[:per_page] = cookies[:per_page]
       end
 
-      if @parent_model.present?
+      if @parent_record.present?
         @index_params[:per_page] = Avo.configuration.via_per_page
       end
 
@@ -324,8 +309,20 @@ module Avo
       @index_params[:sort_direction] = params[:sort_direction] || :desc
 
       # View types
-      @index_params[:view_type] = params[:view_type] || @resource.default_view_type || Avo.configuration.default_view_type
-      @index_params[:available_view_types] = @resource.available_view_types
+      available_view_types = @resource.available_view_types
+      @index_params[:available_view_types] = available_view_types
+
+      @index_params[:view_type] = if params[:view_type].present?
+        params[:view_type]
+      elsif available_view_types.size == 1
+        available_view_types.first
+      else
+        @resource.default_view_type || Avo.configuration.default_view_type
+      end
+
+      if available_view_types.exclude? @index_params[:view_type].to_sym
+        raise "View type '#{@index_params[:view_type]}' is unavailable for #{@resource.class}."
+      end
     end
 
     def set_filters
@@ -343,7 +340,7 @@ module Avo
       @actions = @resource
         .get_actions
         .map do |action|
-          action[:class].new(model: @model, resource: @resource, view: @view, arguments: action[:arguments])
+          action[:class].new(record: @record, resource: @resource, view: @view, arguments: action[:arguments])
         end
         .select do |action|
           action.visible_in_view(parent_resource: @parent_resource)
@@ -397,45 +394,41 @@ module Avo
     end
 
     def set_edit_title_and_breadcrumbs
-      @resource = @resource.hydrate(model: @model, view: :edit, user: _current_user)
+      @resource = @resource.hydrate(record: @record, view: :edit, user: _current_user)
       @page_title = @resource.default_panel_name.to_s
 
       last_crumb_args = {}
       # If we're accessing this resource via another resource add the parent to the breadcrumbs.
-      if params[:via_resource_class].present? && params[:via_resource_id].present?
-        via_resource = Avo::App.get_resource(params[:via_resource_class]).dup
-        via_model = via_resource.find_record params[:via_resource_id], params: params
-        via_resource.hydrate model: via_model
+      if params[:via_resource_class].present? && params[:via_record_id].present?
+        via_resource = Avo.resource_manager.get_resource(params[:via_resource_class])
+        via_record = via_resource.find_record params[:via_record_id], params: params
+        via_resource = via_resource.new record: via_record
 
         add_breadcrumb via_resource.plural_name, resources_path(resource: @resource)
-        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource)
+        add_breadcrumb via_resource.record_title, resource_path(record: via_record, resource: via_resource)
 
         last_crumb_args = {
           via_resource_class: params[:via_resource_class],
-          via_resource_id: params[:via_resource_id]
+          via_record_id: params[:via_record_id]
         }
       else
         add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
       end
 
-      add_breadcrumb @resource.model_title, resource_path(model: @resource.model, resource: @resource, **last_crumb_args)
+      add_breadcrumb @resource.record_title, resource_path(record: @resource.record, resource: @resource, **last_crumb_args)
       add_breadcrumb t("avo.edit").humanize
     end
 
     def create_success_action
-      return render "close_modal_and_reload_field" if params[:via_belongs_to_resource_class].present?
-
       respond_to do |format|
         format.html { redirect_to after_create_path, notice: create_success_message}
       end
     end
 
     def create_fail_action
-      flash.now[:error] = create_fail_message
-
       respond_to do |format|
+        flash.now[:error] = create_fail_message
         format.html { render :new, status: :unprocessable_entity }
-        format.turbo_stream { render "create_fail_action" }
       end
     end
 
@@ -450,13 +443,13 @@ module Avo
     def after_create_path
       # If this is an associated record return to the association show page
       if is_associated_record?
-        parent_resource = ::Avo::App.get_resource_by_model_name(params[:via_relation_class]).dup
-        association_name = BaseResource.valid_association_name(@model, params[:via_relation])
+        parent_resource = Avo.resource_manager.get_resource_by_model_class(params[:via_relation_class])
+        association_name = BaseResource.valid_association_name(@record, params[:via_relation])
 
         return resource_view_path(
-          model: @model.send(association_name),
+          record: @record.send(association_name),
           resource: parent_resource,
-          resource_id: params[:via_resource_id]
+          resource_id: params[:via_record_id]
         )
       end
 
@@ -492,7 +485,7 @@ module Avo
 
     # Needs a different name, otwherwise, in some places, this can be called instead helpers.resource_view_path
     def resource_view_response_path
-      helpers.resource_view_path(model: @model, resource: @resource)
+      helpers.resource_view_path(record: @record, resource: @resource)
     end
 
     def destroy_success_action
@@ -502,10 +495,8 @@ module Avo
     end
 
     def destroy_fail_action
-      flash[:error] = destroy_fail_message
-
       respond_to do |format|
-        format.turbo_stream { render partial: "avo/partials/flash_alerts" }
+        format.html { redirect_back fallback_location: params[:referrer] || resources_path(resource: @resource, turbo_frame: params[:turbo_frame], view_type: params[:view_type]), error: destroy_fail_message }
       end
     end
 
@@ -527,14 +518,14 @@ module Avo
       if @resource.class.send(action) == :index
         resources_path(resource: @resource)
       elsif @resource.class.send(action) == :edit || Avo.configuration.resource_default_view == :edit
-        edit_resource_path(resource: @resource, model: @resource.model)
+        edit_resource_path(resource: @resource, record: @resource.record)
       else
-        resource_path(model: @model, resource: @resource)
+        resource_path(record: @record, resource: @resource)
       end
     end
 
     def is_associated_record?
-      params[:via_relation_class].present? && params[:via_resource_id].present?
+      params[:via_relation_class].present? && params[:via_record_id].present?
     end
 
     # Set pagy locale from params or from avo configuration, if both nil locale = "en"
@@ -542,8 +533,12 @@ module Avo
       @pagy_locale = locale.to_s || Avo.configuration.locale || "en"
     end
 
-    def apply_pagination
-      @pagy, @models = @resource.apply_pagination(index_params: @index_params, query: @query)
+    def safe_call(method)
+      send(method) if respond_to?(method, true)
+    end
+
+    def pagy_query
+      @query
     end
   end
 end

data/app/controllers/avo/debug_controller.rb

@@ -2,7 +2,19 @@ require_dependency "avo/application_controller"
 
 module Avo
   class DebugController < ApplicationController
-    def index
+    def status
+    end
+
+    def send_to_hq
+      url = "#{ENV["HQ_URL"]}/api/v3/debug_requests"
+      timeout = 10 # seconds
+      license_key = Avo::Services::DebugService.debug_report(request)[:hq_payload][:license_key]
+      body = params[:body]
+      body = {license_key: license_key, body: body, payload: Avo::Services::DebugService.debug_report(request).to_json}.to_json
+
+      HTTParty.post url, body: body, headers: {"Content-Type": "application/json"}, timeout: timeout
+
+      render turbo_stream: turbo_stream.replace(:send_to_hq, plain: "Payload sent to Avo HQ.")
     end
 
     def report
@@ -13,13 +25,13 @@ module Avo
 
       if license.valid?
         flash[:notice] = "avohq.io responded: \"#{license.id.humanize} license is valid\"."
-      elsif license.response['reason'].present?
-        flash[:error] = "avohq.io responded: \"#{license.response['reason']}\"."
+      elsif license.response["reason"].present?
+        flash[:error] = "avohq.io responded: \"#{license.response["reason"]}\"."
       else
-        flash[:error] = license.response['error']
+        flash[:error] = license.response["error"]
       end
 
-      redirect_back fallback_location: avo.avo_private_debug_index_path
+      redirect_back fallback_location: avo.avo_private_status_path
     end
   end
 end

data/app/controllers/avo/home_controller.rb

@@ -14,7 +14,7 @@ module Avo
         redirect_to computed_path
       elsif !Rails.env.development?
         @page_title = "Get started"
-        resource = Avo::App.resources.min_by { |resource| resource.model_key }
+        resource = Avo.resource_manager.all.min_by { |resource| resource.model_key }
         redirect_to resources_path(resource: resource)
       end
     end

data/app/controllers/avo/search_controller.rb

@@ -4,18 +4,8 @@ module Avo
   class SearchController < ApplicationController
     include Rails.application.routes.url_helpers
 
-    before_action :set_resource_name, only: [:show]
-    before_action :set_resource, only: [:show]
-
-    def index
-      raise ActionController::BadRequest.new("This feature requires the pro license https://avohq.io/purchase/pro") if App.license.lacks_with_trial(:global_search)
-
-      resources = Avo::App.resources.reject do |resource|
-        resource.class.hide_from_global_search
-      end
-
-      render json: search_resources(resources)
-    end
+    before_action :set_resource_name, only: :show
+    before_action :set_resource, only: :show
 
     def show
       render json: search_resources([resource])
@@ -28,7 +18,6 @@ module Avo
         .map do |resource|
           # Apply authorization
           next unless @authorization.set_record(resource.model_class).authorize_action(:search, raise_exception: false)
-
           # Filter out the models without a search_query
           next if resource.search_query.nil?
 
@@ -45,20 +34,20 @@ module Avo
     end
 
     def search_resource(resource)
-      query = Avo::Hosts::SearchScopeHost.new(
-        block: resource.search_query,
+      query = Avo::ExecutionContext.new(
+        target: resource.search_query,
         params: params,
-        scope: resource.class.scope
+        query: resource.query_scope
       ).handle
 
-      query = apply_scope(query) if should_apply_any_scope?
-
       # Get the count
       results_count = query.reselect(resource.model_class.primary_key).count
 
       # Get the results
       query = query.limit(8)
 
+      query = apply_scope(query) if should_apply_any_scope?
+
       results = apply_search_metadata(query, resource)
 
       header = resource.plural_name
@@ -69,9 +58,9 @@ module Avo
 
       result_object = {
         header: header,
-        help: resource.class.search_query_help,
+        help: resource.fetch_search(:help) || "",
         results: results,
-        count: results_count
+        count: results.count
       }
 
       [resource.name.pluralize.downcase, result_object]
@@ -96,9 +85,9 @@ module Avo
       # to scope the query.
       # Example usage: Got to a project, create a new review, and search for a user.
       if parent.blank? && params[:via_parent_resource_id].present? && params[:via_parent_resource_class].present? && params[:via_relation].present?
-        parent_resource_class = BaseResource.valid_model_class params[:via_parent_resource_class]
+        parent_resource_class = BaseResource.get_model_by_name params[:via_parent_resource_class]
 
-        reflection_class = BaseResource.valid_model_class params[:via_reflection_class]
+        reflection_class = BaseResource.get_model_by_name params[:via_reflection_class]
 
         grandparent = parent_resource_class.find params[:via_parent_resource_id]
         parent = reflection_class.new(
@@ -106,7 +95,7 @@ module Avo
         )
       end
 
-      Avo::Hosts::AssociationScopeHost.new(block: attach_scope, query: query, parent: parent).handle
+      Avo::ExecutionContext.new(target: attach_scope, query: query, parent: parent).handle
     end
 
     # This scope is applied if the search is being performed on a has_many association
@@ -114,44 +103,34 @@ module Avo
       association_name = BaseResource.valid_association_name(parent, params[:via_association_id])
 
       # Get association records
-      scope = parent.send(association_name)
+      query = parent.send(association_name)
 
       # Apply policy scope if authorization is present
-      scope = resource.authorization&.apply_policy scope
+      query = resource.authorization&.apply_policy query
 
-      Avo::Hosts::SearchScopeHost.new(block: @resource.search_query, params: params, scope: scope).handle
+      Avo::ExecutionContext.new(target: @resource.class.search_query, params: params, query: query).handle
     end
 
-    def apply_search_metadata(models, avo_resource)
-      models.map do |model|
-        resource = avo_resource.dup.hydrate(model: model).hydrate_fields(model: model)
-
-        record_path = if resource.search_result_path.present?
-          Avo::Hosts::ResourceRecordHost.new(block: resource.search_result_path, resource: resource, record: model).handle
-        else
-          resource.record_path
-        end
+    def apply_search_metadata(records, avo_resource)
+      records.map do |record|
+        resource = avo_resource.new(record: record)
 
-        result = {
-          _id: model.id,
-          _label: resource.label,
-          _url: record_path
-        }
-
-        if App.license.has_with_trial(:enhanced_search_results)
-          result[:_description] = resource.description
-          result[:_avatar] = resource.avatar.present? ? main_app.url_for(resource.avatar) : nil
-          result[:_avatar_type] = resource.avatar_type
-        end
-
-        result
+        fetch_result_information record, resource, resource.class.fetch_search(:item, record: record)
       end
     end
 
     private
 
+    def fetch_result_information(record, resource, item)
+      {
+        _id: record.id,
+        _label: item&.dig(:title) || resource.record_title,
+        _url: resource.class.fetch_search(:result_path, record: resource.record) || resource.record_path
+      }
+    end
+
     def should_apply_has_many_scope?
-      params[:via_association] == "has_many" && @resource.search_query.present?
+      params[:via_association] == "has_many" && @resource.class.search_query.present?
     end
 
     def should_apply_attach_scope?
@@ -175,14 +154,14 @@ module Avo
     end
 
     def fetch_field
-      fields = ::Avo::App.get_resource_by_model_name(params[:via_reflection_class]).get_field_definitions
+      fields = Avo.resource_manager.get_resource_by_model_class(params[:via_reflection_class]).new.get_field_definitions
       fields.find { |f| f.id.to_s == params[:via_association_id] }
     end
 
     def fetch_parent
       return unless params[:via_reflection_id].present?
 
-      parent_resource = ::Avo::App.get_resource_by_model_name params[:via_reflection_class]
+      parent_resource = Avo.resource_manager.get_resource_by_model_class params[:via_reflection_class]
       parent_resource.find_record params[:via_reflection_id], params: params
     end
   end

data/app/controllers/avo/team_users_controller.rb

@@ -0,0 +1,4 @@
+# This controller has been generated to enable Rails' resource routes.
+# You shouldn't need to modify it in order to use Avo.
+class Avo::TeamUsersController < Avo::ResourcesController
+end