avo 2.43.0 → 3.0.2

data/lib/avo/resources/items/holder.rb

@@ -0,0 +1,96 @@
+class Avo::Resources::Items::Holder
+  attr_reader :tools, :from
+  attr_accessor :items
+  attr_accessor :invalid_fields
+
+  def initialize(from: nil, parent: nil)
+    @items = []
+    @items_index = 0
+    @invalid_fields = []
+    @from = from
+    @parent = parent
+  end
+
+  # Adds a field to the items_holder
+  def field(field_name, **args, &block)
+    # If the field is paresed inside a tab group, add it to the tab
+    # This will happen when the field is parsed inside a tab group from a resource method
+    if from.present? && from.class == Avo::Resources::Items::TabGroup::Builder
+      return from.field(field_name, holder: self, **args, &block)
+    end
+
+    field_parser = Avo::Dsl::FieldParser.new(id: field_name, order_index: @items_index, **args, &block).parse
+
+    if field_parser.invalid?
+      as = args.fetch(:as, nil)
+
+      # End execution ehre and add the field to the invalid_fileds payload so we know to wanr the developer about that.
+      # @todo: Make sure this warning is still active
+      return add_invalid_field({
+        name: field_name,
+        as: as,
+        # resource: resource_class.name,
+        message: "There's an invalid field configuration for this resource. <br/> <code class='px-1 py-px rounded bg-red-600'>field :#{field_name}, as: :#{as}</code>"
+      })
+    end
+
+    add_item field_parser.instance
+  end
+
+  def tabs(tab = nil, **kwargs, &block)
+    if tab.present?
+      add_item tab
+    else
+      add_item Avo::Resources::Items::TabGroup::Builder.parse_block(parent: @parent, **kwargs, &block)
+    end
+  end
+
+  def tab(name, **args, &block)
+    add_item Avo::Resources::Items::Tab::Builder.parse_block(name: name, parent: @parent, **args, &block)
+  end
+
+  def row(**args, &block)
+    add_item Avo::Resources::Items::Row::Builder.parse_block(parent: @parent, **args, &block)
+  end
+
+  def tool(klass, **args)
+    add_item klass.new(**args)
+  end
+
+  def panel(panel_name = nil, **args, &block)
+    add_item Avo::Resources::Items::ItemGroup::Builder.parse_block(name: panel_name, parent: @parent, **args, &block)
+  end
+
+  # The main panel is the one that also render the header of the resource with the breadcrumbs, the title and the controls.
+  def main_panel(**args, &block)
+    add_item Avo::Resources::Items::MainPanel::Builder.parse_block(name: "main_panel", parent: @parent, **args, &block)
+  end
+
+  def sidebar(**args, &block)
+    check_sidebar_is_inside_a_panel
+
+    add_item Avo::Resources::Items::Sidebar::Builder.parse_block(parent: @parent, **args, &block)
+  end
+
+  def add_item(instance)
+    @items << instance
+
+    increment_order_index
+  end
+
+  private
+
+  def add_invalid_field(payload)
+    invalid_fields << payload
+  end
+
+  def increment_order_index
+    @items_index += 1
+  end
+
+  def check_sidebar_is_inside_a_panel
+    unless @from.eql?(Avo::Resources::Items::Panel::Builder) || @from.eql?(Avo::Resources::Items::MainPanel::Builder)
+      raise "The sidebar must be inside a panel."
+    end
+  end
+end

data/lib/avo/resources/items/item_group.rb

@@ -0,0 +1,44 @@
+class Avo::Resources::Items::ItemGroup
+  prepend Avo::Concerns::IsResourceItem
+
+  include Avo::Concerns::HasItems
+  include Avo::Concerns::HasItemType
+  include Avo::Concerns::VisibleItems
+  include Avo::Concerns::VisibleInDifferentViews
+
+  attr_reader :name
+  attr_reader :description
+
+  delegate :items, :add_item, to: :items_holder
+
+  def initialize(name: nil, description: nil, view: nil, **args)
+    @name = name
+    @view = Avo::ViewInquirer.new view
+    @description = description
+    @items_holder = Avo::Resources::Items::Holder.new
+    @args = args
+
+    post_initialize if respond_to?(:post_initialize)
+  end
+
+  class Builder
+    include Avo::Concerns::BorrowItemsHolder
+
+    delegate :heading, to: :items_holder
+    delegate :field, to: :items_holder
+    delegate :row, to: :items_holder
+    delegate :items, to: :items_holder
+    delegate :sidebar, to: :items_holder
+
+    def initialize(parent:, name: nil, **args)
+      @panel = Avo::Resources::Items::Panel.new(name: name, **args)
+      @items_holder = Avo::Resources::Items::Holder.new(from: self.class, parent: parent)
+    end
+
+    # Fetch the tab
+    def build
+      @panel.items_holder = @items_holder
+      @panel
+    end
+  end
+end

data/lib/avo/resources/items/main_panel.rb

@@ -0,0 +1,12 @@
+class Avo::Resources::Items::MainPanel < Avo::Resources::Items::Panel
+  class Builder < Avo::Resources::Items::ItemGroup::Builder
+    def initialize(parent: ,**args)
+      @panel = Avo::Resources::Items::MainPanel.new(**args)
+      @items_holder = Avo::Resources::Items::Holder.new(from: self.class, parent: parent)
+    end
+  end
+
+  def visible?
+    true
+  end
+end

data/lib/avo/resources/items/panel.rb

@@ -0,0 +1,2 @@
+class Avo::Resources::Items::Panel < Avo::Resources::Items::ItemGroup
+end

data/lib/avo/resources/items/row.rb

@@ -0,0 +1,42 @@
+class Avo::Resources::Items::Row
+  include Avo::Concerns::IsResourceItem
+  include Avo::Concerns::HasItems
+  include Avo::Concerns::HasItemType
+  include Avo::Concerns::VisibleItems
+  include Avo::Concerns::Hydration
+
+  class_attribute :item_type, default: :row
+
+  attr_reader :view
+  attr_accessor :items_holder
+
+  delegate :items, :add_item, to: :items_holder
+
+  def initialize(view: nil)
+    @view = Avo::ViewInquirer.new view
+    @items_holder = Avo::Resources::Items::Holder.new
+  end
+
+  def has_items?
+    @items.present?
+  end
+
+  class Builder
+    include Avo::Concerns::BorrowItemsHolder
+
+    delegate :field, to: :items_holder
+    delegate :tool, to: :items_holder
+    delegate :items, to: :items_holder
+
+    def initialize(parent:, **args)
+      @row = Avo::Resources::Items::Row.new(**args)
+      @items_holder = Avo::Resources::Items::Holder.new(parent: @parent)
+    end
+
+    # Fetch the tab
+    def build
+      @row.items_holder = @items_holder
+      @row
+    end
+  end
+end

data/lib/avo/resources/items/sidebar.rb

@@ -0,0 +1,46 @@
+class Avo::Resources::Items::Sidebar
+  prepend Avo::Concerns::IsResourceItem
+
+  include Avo::Concerns::HasItems
+  include Avo::Concerns::HasItemType
+  include Avo::Concerns::IsVisible
+  include Avo::Concerns::VisibleInDifferentViews
+
+  delegate :items, :add_item, to: :items_holder
+
+  attr_reader :name
+
+  def initialize(name: nil, view: nil, **args)
+    @name = name
+    @items_holder = Avo::Resources::Items::Holder.new
+    @view = Avo::ViewInquirer.new view
+    @panel_wrapper = args[:panel_wrapper].nil? ? true : args[:panel_wrapper]
+    @args = args
+
+    post_initialize if respond_to?(:post_initialize)
+  end
+
+  def panel_wrapper?
+    @panel_wrapper
+  end
+
+  class Builder
+    include Avo::Concerns::BorrowItemsHolder
+
+    delegate :field, to: :items_holder
+    delegate :tool, to: :items_holder
+    delegate :items, to: :items_holder
+    delegate :heading, to: :items_holder
+
+    def initialize(parent: , name: nil, **args)
+      @sidebar = Avo::Resources::Items::Sidebar.new(**args)
+      @items_holder = Avo::Resources::Items::Holder.new(parent: parent)
+    end
+
+    # Fetch the sidebar
+    def build
+      @sidebar.items_holder = @items_holder
+      @sidebar
+    end
+  end
+end

data/lib/avo/resources/items/tab.rb

@@ -0,0 +1,54 @@
+class Avo::Resources::Items::Tab
+  prepend Avo::Concerns::IsResourceItem
+
+  include Avo::Concerns::HasItems
+  include Avo::Concerns::HasItemType
+  include Avo::Concerns::VisibleItems
+  include Avo::Concerns::VisibleInDifferentViews
+
+  delegate :items, :add_item, to: :items_holder
+
+  attr_accessor :description
+
+  def initialize(name: nil, description: nil, view: nil, **args)
+    @name = name
+    @description = description
+    @items_holder = Avo::Resources::Items::Holder.new
+    @view = Avo::ViewInquirer.new view
+    @args = args
+
+    post_initialize if respond_to?(:post_initialize)
+  end
+
+  def name
+    Avo::ExecutionContext.new(target: @name).handle
+  end
+
+  def turbo_frame_id(parent: nil)
+    id = "#{Avo::Resources::Items::Tab.to_s.parameterize} #{name}".parameterize
+
+    return id if parent.nil?
+
+    "#{parent.turbo_frame_id} #{id}".parameterize
+  end
+
+  class Builder
+    include Avo::Concerns::BorrowItemsHolder
+
+    delegate :field, to: :items_holder
+    delegate :tool, to: :items_holder
+    delegate :panel, to: :items_holder
+    delegate :items, to: :items_holder
+
+    def initialize(parent:, name: nil, **args)
+      @tab = Avo::Resources::Items::Tab.new(name: name, **args)
+      @items_holder = Avo::Resources::Items::Holder.new(parent: parent)
+    end
+
+    # Fetch the tab
+    def build
+      @tab.items_holder = @items_holder
+      @tab
+    end
+  end
+end

data/lib/avo/resources/items/tab_group.rb

@@ -0,0 +1,62 @@
+class Avo::Resources::Items::TabGroup
+  prepend Avo::Concerns::IsResourceItem
+
+  include Avo::Concerns::HasItems
+  include Avo::Concerns::HasItemType
+  include Avo::Concerns::IsVisible
+  include Avo::Concerns::VisibleInDifferentViews
+
+  attr_accessor :index
+  attr_accessor :style
+
+  def initialize(index: 0, view: nil, style: nil, **args)
+    @index = index
+    @items_holder = Avo::Resources::Items::Holder.new
+    @view = Avo::ViewInquirer.new view
+    @style = style
+    @args = args
+
+    post_initialize if respond_to?(:post_initialize)
+  end
+
+  def turbo_frame_id
+    "#{Avo::Resources::Items::TabGroup.to_s.parameterize} #{index}".parameterize
+  end
+
+  class Builder
+    include Avo::Concerns::BorrowItemsHolder
+
+    delegate :tab, to: :items_holder
+
+    def field(field_name, **args, &block)
+      parsed = Avo::Dsl::FieldParser.new(id: field_name, order_index: @items_index, **args, &block).parse
+      field_instance = parsed.instance
+
+      name = field_instance.name
+      tab = Avo::Resources::Items::Tab.new name: name
+
+      if field_instance.has_own_panel?
+        tab.items_holder.add_item parsed.instance
+      else
+        # If the field is not in a panel, create one and add it
+        panel = Avo::Resources::Items::Panel.new name: name
+        panel.items_holder.add_item parsed.instance
+        # Add that panel to the items_holder
+        tab.items_holder.add_item panel
+      end
+
+      @items_holder.tabs tab
+    end
+
+    def initialize(parent: ,style: nil)
+      @group = Avo::Resources::Items::TabGroup.new(style: style)
+      @items_holder = Avo::Resources::Items::Holder.new(parent: parent, from: self)
+    end
+
+    # Fetch the tab
+    def build
+      @group.items_holder = @items_holder
+      @group
+    end
+  end
+end

data/lib/avo/resources/resource_manager.rb

@@ -0,0 +1,179 @@
+module Avo
+  module Resources
+    class ResourceManager
+      attr_accessor :resources
+
+      alias_method :all, :resources
+
+      class << self
+        def build
+          instance = new
+          instance.init_resources
+          instance.check_bad_resources
+          instance
+        end
+
+        # Fetches the resources available to the application.
+        # We have two ways of doing that.
+        #
+        # 1. Through eager loading.
+        # We automatically eager load the resources directory and fetch the descendants from the scanned files.
+        # This is the simple way to get started.
+        #
+        # 2. Manually, declared by the user.
+        # We have this option to load the resources because when they are loaded automatically through eager loading,
+        # those Resource classes and their methods may trigger loading other classes. And that may disrupt Rails booting process.
+        # Ex: AdminResource may use self.model_class = User. That will trigger Ruby to load the User class and itself load
+        # other classes in a chain reaction.
+        # The scenario that comes up most often is when Rails boots, the routes are being computed which eager loads the resource files.
+        # At that boot time some migration might have not been run yet, but Rails tries to access them through model associations,
+        # and they are not available.
+        #
+        # To enable this feature add a `resources` array config in your Avo initializer.
+        # config.resources = [
+        #   "UserResource",
+        #   "FishResource",
+        # ]
+        def fetch_resources
+          resources = if Avo.configuration.resources.nil?
+            BaseResource.descendants
+          else
+            Avo.configuration.resources
+          end
+
+          resources.map do |resource|
+            if resource.is_a?(Class)
+              resource
+            else
+              resource.to_s.safe_constantize
+            end
+          end
+        end
+      end
+
+      def initialize
+        @resources = []
+      end
+
+      def init_resources
+        self.resources = self.class.fetch_resources
+          .reject do |resource|
+            # Remove the BaseResource. We only need the descendants
+            resource == Avo::BaseResource
+          end
+          .uniq do |klass|
+            # On invalid resource configuration the resource classes get duplicated in `ObjectSpace`
+            # We need to de-duplicate them
+            klass.name
+          end
+      end
+
+      def check_bad_resources
+        resources.each do |resource|
+          has_model = resource.model_class.present?
+
+          unless has_model
+            possible_model = resource.to_s.gsub "Avo::Resources::", ""
+            possible_model = possible_model.gsub "Resource", ""
+
+            Avo.error_manager.add({
+              url: "https://docs.avohq.io/2.0/resources.html#custom-model-class",
+              target: "_blank",
+              message: "#{resource} does not have a valid model assigned. It failed to find the #{possible_model} model. \n\r Please create that model or assign one using self.model_class = YOUR_MODEL"
+            })
+          end
+        end
+      end
+
+      # Filters out the resources that are missing the model_class
+      def valid_resources
+        resources.select { |resource| resource.model_class.present? }.sort_by(&:name)
+      end
+
+      # Returns the Avo resource by camelized name
+      #
+      # get_resource_by_name('User') => instance of Avo::Resources::User
+      def get_resource(resource)
+        resource = "Avo::Resources::#{resource}" unless resource.to_s.starts_with?("Avo::Resources::")
+
+        resources.find do |available_resource|
+          resource.to_s == available_resource.to_s
+        end
+      end
+
+      # Returns the Avo resource by singular snake_cased name
+      #
+      # get_resource_by_name('user') => instance of Avo::Resources::User
+      def get_resource_by_name(name)
+        get_resource name.singularize.camelize
+      end
+
+      # Returns the Avo resource by singular snake_cased name
+      # From all the resources that use the same model_class, it will fetch the first one in alphabetical order
+      #
+      # get_resource_by_name('User') => instance of Avo::Resources::User
+      # get_resource_by_name(User) => instance of Avo::Resources::User
+
+      def get_resource_by_model_class(klass)
+        # Fetch the mappings imposed by the user.
+        # If they are present, use those ones.
+        mapping = get_mapping_for_model klass
+        return get_resource(mapping) if mapping.present?
+
+        valid_resources
+          .find do |resource|
+            resource.model_class.model_name.name == klass.to_s
+          end
+      end
+
+      # Returns the Avo resource by singular snake_cased name
+      #
+      # get_resource_by_controller_name('delayed_backend_active_record_jobs') => instance of Avo::Resources::DelayedJob
+      # get_resource_by_controller_name('users') => instance of Avo::Resources::User
+      def get_resource_by_controller_name(name)
+        valid_resources
+          .find do |resource|
+            resource.model_class.to_s.pluralize.underscore.tr("/", "_") == name.to_s
+          end
+      end
+
+      # Returns the Avo resource by some name
+      def guess_resource(name)
+        get_resource_by_name(name.to_s) || get_resource_by_model_class(name)
+      end
+
+      # Returns the Rails model class by singular snake_cased name
+      #
+      # get_model_class_by_name('user') => User
+      def get_model_class_by_name(name)
+        name.to_s.camelize.singularize
+      end
+
+      def get_available_resources(user = nil)
+        valid_resources
+          .select do |resource|
+            resource.authorization.class.authorize(
+              user,
+              resource.model_class,
+              Avo.configuration.authorization_methods.stringify_keys["index"],
+              raise_exception: false
+            )
+          end
+          .sort_by { |r| r.name }
+      end
+
+      def resources_for_navigation(user = nil)
+        get_available_resources(user)
+          .select do |resource|
+            resource.visible_on_sidebar
+          end
+      end
+
+      private
+
+      def get_mapping_for_model(klass)
+        (Avo.configuration.model_resource_mapping || {}).stringify_keys.transform_values(&:to_s)[klass.to_s]
+      end
+    end
+  end
+end

data/lib/avo/services/authorization_service.rb

@@ -6,109 +6,19 @@ module Avo
       attr_accessor :policy_class
 
       class << self
-        def client
-          client = Avo.configuration.authorization_client
-
-          client = nil if Avo::App.license.lacks(:authorization)
-
-          klass = case client
-          when nil
-            nil_client
-          when :pundit
-            pundit_client
-          else
-            if client.is_a?(String)
-              client.safe_constantize
-            else
-              client
-            end
-          end
-
-          klass.new
-        end
-
-        def authorize(user, record, action, policy_class: nil, **args)
-          return true if skip_authorization
-
-          client.authorize user, record, action, policy_class: policy_class
-
+        def authorize(*args, **kwargs)
           true
-        rescue NoPolicyError => error
-          # By default, Avo allows anything if you don't have a policy present.
-          return true unless Avo.configuration.raise_error_on_missing_policy
-
-          raise error
-        rescue => error
-          if args[:raise_exception] == false
-            false
-          else
-            raise error
-          end
         end
 
-        def authorize_action(user, record, action, policy_class: nil, **args)
-          action = Avo.configuration.authorization_methods.stringify_keys[action.to_s] || action
-
-          # If no action passed we should raise error if the user wants that.
-          # If not, just allow it.
-          if action.nil?
-            raise NoPolicyError.new "Policy method is missing" if Avo.configuration.raise_error_on_missing_policy
-
-            return true
-          end
-
-          # Add the question mark if it's missing
-          action = "#{action}?" unless action.end_with? "?"
-          authorize(user, record, action, policy_class: policy_class, **args)
-        end
-
-        def apply_policy(user, model, policy_class: nil)
-          return model if skip_authorization
-
-          client.apply_policy(user, model, policy_class: policy_class)
-        rescue NoPolicyError => error
-          return model unless Avo.configuration.raise_error_on_missing_policy
-
-          raise error
-        end
-
-        def skip_authorization
-          Avo::App.license.lacks_with_trial :authorization
-        end
-
-        def defined_methods(user, record, policy_class: nil, **args)
-          return client.policy!(user, record).methods if policy_class.nil?
-
-          # I'm aware this will not raise a Pundit error.
-          # Should the policy not exist, it will however raise an uninitialized constant error, which is probably what we want when specifying a custom policy
-          policy_class.new(user, record).methods
-        rescue NoPolicyError => error
-          return [] unless Avo.configuration.raise_error_on_missing_policy
-
-          raise error
-        rescue => error
-          if args[:raise_exception] == false
-            []
-          else
-            raise error
-          end
-        end
-
-        def pundit_client
-          raise Avo::MissingGemError.new("Please add `gem 'pundit'` to your Gemfile.") unless defined?(Pundit)
-
-          Avo::Services::AuthorizationClients::PunditClient
-        end
-
-        def nil_client
-          Avo::Services::AuthorizationClients::NilClient
+        def apply_policy(user, query)
+          query
         end
       end
 
       def initialize(user = nil, record = nil, policy_class: nil)
         @user = user
         @record = record
-        @policy_class = policy_class || self.class.client.policy(user, record)&.class
+        @policy_class = NilPolicy
       end
 
       def set_record(record)
@@ -117,28 +27,19 @@ module Avo
         self
       end
 
-      def authorize_action(action, **args)
-        self.class.authorize_action(user, args[:record] || record, action, policy_class: policy_class, **args)
+      def apply_policy(query)
+        query
       end
 
-      def apply_policy(model)
-        self.class.apply_policy(user, model, policy_class: policy_class)
+      def authorize_action(*args)
+        true
       end
 
-      def defined_methods(model, **args)
-        self.class.defined_methods(user, model, policy_class: policy_class, **args)
+      def has_method?(*args, **kwargs)
+        false
       end
 
-      def has_method?(method, **args)
-        method = "#{method}?" unless method.to_s.end_with? "?"
-        defined_methods(args[:record] || record, **args).include? method.to_sym
-      end
-
-      # Check the received method to see if the user overrode it in their config and then checks if it's present on the policy.
-      def has_action_method?(method, **args)
-        method = Avo.configuration.authorization_methods.stringify_keys[method.to_s] || method
-
-        has_method? method, **args
+      class NilPolicy
       end
     end
   end