avo 2.48.0 → 3.0.0.beta1

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

@@ -0,0 +1,68 @@
+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 = 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
+    class << self
+      def parse_block(**args, &block)
+        Docile.dsl_eval(new(**args), &block).build
+      end
+    end
+
+    attr_reader :items_holder
+
+    delegate :tab, to: :items_holder
+
+    def initialize(style: nil)
+      @group = Avo::Resources::Items::TabGroup.new(style: style)
+      @items_holder = Avo::Resources::Items::Holder.new
+    end
+
+    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
+
+    # Fetch the tab
+    def build
+      @group.items_holder = @items_holder
+      @group
+    end
+  end
+end

data/lib/avo/resources/resource_manager.rb

@@ -0,0 +1,174 @@
+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|
+            Services::AuthorizationService.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

data/lib/avo/services/debug_service.rb

@@ -0,0 +1,93 @@
+class Avo::Services::DebugService
+  class << self
+    def debug_report(request = nil)
+      payload = {}
+
+      hq = Avo::Licensing::HQ.new(request)
+
+      payload[:license_id] = Avo::Current&.license&.id
+      payload[:license_valid] = Avo::Current&.license&.valid?
+      payload[:license_payload] = Avo::Current&.license&.payload
+      payload[:license_response] = Avo::Current&.license&.response
+      payload[:hq_payload] = hq&.payload
+      payload[:thread_count] = get_thread_count
+      payload[:license_abilities] = Avo::Current&.license&.abilities
+      payload[:cache_store] = Avo.cache_store&.class&.to_s
+      payload[:avo_metadata] = avo_metadata
+      payload[:app_timezone] = Time.current.zone
+      payload[:cache_key] = Avo::Licensing::HQ.cache_key
+      payload[:cache_key_contents] = hq&.cached_response
+      payload[:plugins] = Avo.plugin_manager
+
+      payload
+    rescue => e
+      e
+    end
+
+    def get_thread_count
+      Thread.list.count { |thread| thread.status == "run" }
+    rescue => e
+      e
+    end
+
+    def avo_metadata
+      resources = Avo.resource_manager.all
+      dashboards = defined?(Avo::Dashboards) ? Avo::Dashboards.dashboard_manager.all : []
+      field_definitions = resources.map(&:get_field_definitions)
+      fields_count = field_definitions.map(&:count).sum
+      fields_per_resource = sprintf("%0.01f", fields_count / (resources.count + 0.0))
+
+      field_types = {}
+      custom_fields_count = 0
+      field_definitions.each do |fields|
+        fields.each do |field|
+          field_types[field.type] ||= 0
+          field_types[field.type] += 1
+
+          custom_fields_count += 1 if field.custom?
+        end
+      end
+
+      {
+        resources_count: resources.count,
+        dashboards_count: dashboards.count,
+        fields_count: fields_count,
+        fields_per_resource: fields_per_resource,
+        custom_fields_count: custom_fields_count,
+        field_types: field_types,
+        # **other_metadata(:actions), # TODO: this is fetching actions without hydration
+        **other_metadata(:filters),
+        main_menu_present: Avo.configuration.main_menu.present?,
+        profile_menu_present: Avo.configuration.profile_menu.present?,
+        cache_store: Avo.cache_store&.class&.to_s,
+        **config_metadata
+      }
+    # rescue => error
+    #   {
+    #     error: error.message
+    #   }
+    end
+
+    def other_metadata(type = :actions)
+      resources = Avo.resource_manager.all
+
+      types = resources.map(&:"get_#{type}")
+      type_count = types.flatten.uniq.count
+      type_per_resource = sprintf("%0.01f", types.map(&:count).sum / (resources.count + 0.0))
+
+      {
+        "#{type}_count": type_count,
+        "#{type}_per_resource": type_per_resource
+      }
+    end
+
+    def config_metadata
+      {
+        config: {
+          root_path: Avo.configuration.root_path,
+          app_name: Avo.configuration.app_name
+        }
+      }
+    end
+  end
+end

data/lib/avo/services/encryption_service.rb

@@ -32,12 +32,16 @@ module Avo
       private
 
       def encryption_key
-        Rails.application.secret_key_base[0..31]
+        secret_key_base[0..31]
       rescue
         # This will fail the decryption process.
         # It's here only to keep Avo from crashing
         SecureRandom.random_bytes(32)
       end
+
+      def secret_key_base
+        ENV["SECRET_KEY_BASE"] || Rails.application.credentials.secret_key_base || Rails.application.secrets.secret_key_base
+      end
     end
   end
 end

data/lib/avo/services/telemetry_service.rb

@@ -0,0 +1,85 @@
+class Avo::Services::TelemetryService
+  class << self
+    def telemetry_info
+      {
+        # license: Avo.configuration.license,
+        # license_key: Avo.configuration.license_key,
+        avo_version: Avo::VERSION,
+        rails_version: Rails::VERSION::STRING,
+        ruby_version: RUBY_VERSION,
+        environment: Rails.env,
+        # ip: current_request&.ip,
+        # host: current_request&.host,
+        # port: current_request&.port,
+        app_name: app_name,
+        avo_metadata: avo_metadata,
+      }
+    end
+
+    def app_name
+      Rails.application.class.to_s.split("::").first
+    rescue
+      nil
+    end
+
+    def avo_metadata
+      resources = Avo.resource_manager.all
+      dashboards = Avo::Current.app.dashboard_manager.all
+      field_definitions = resources.map(&:get_field_definitions)
+      fields_count = field_definitions.map(&:count).sum
+      fields_per_resource = sprintf("%0.01f", fields_count / (resources.count + 0.0))
+
+      field_types = {}
+      custom_fields_count = 0
+      field_definitions.each do |fields|
+        fields.each do |field|
+          field_types[field.type] ||= 0
+          field_types[field.type] += 1
+
+          custom_fields_count += 1 if field.custom?
+        end
+      end
+
+      {
+        resources_count: resources.count,
+        dashboards_count: dashboards.count,
+        fields_count: fields_count,
+        fields_per_resource: fields_per_resource,
+        custom_fields_count: custom_fields_count,
+        field_types: field_types,
+        **other_metadata(:actions),
+        **other_metadata(:filters),
+        main_menu_present: Avo.configuration.main_menu.present?,
+        profile_menu_present: Avo.configuration.profile_menu.present?,
+        cache_store: Avo.cache_store&.class&.to_s,
+        **config_metadata
+      }
+    # rescue => error
+    #   {
+    #     error: error.message
+    #   }
+    end
+
+    def other_metadata(type = :actions)
+      resources = Avo.resource_manager.all
+
+      types = resources.map(&:"get_#{type}")
+      type_count = types.flatten.uniq.count
+      type_per_resource = sprintf("%0.01f", types.map(&:count).sum / (resources.count + 0.0))
+
+      {
+        "#{type}_count": type_count,
+        "#{type}_per_resource": type_per_resource
+      }
+    end
+
+    def config_metadata
+      {
+        config: {
+          root_path: Avo.configuration.root_path,
+          app_name: Avo.configuration.app_name
+        }
+      }
+    end
+  end
+end