avo 0.5.0.beta1 → 0.5.0.beta6

data/config/webpacker.yml

@@ -51,32 +51,19 @@ default: &default
     - .jpeg
     - .jpg
 
+# We override the development env. when packed.
+# Avo needs to be packed and compiled for when the dev uses it in his development env.
 development:
   <<: *default
-  compile: true
 
-  # Verifies that correct packages and versions are installed by inspecting package.json, yarn.lock, and node_modules
-  check_yarn_integrity: true
-
-  # Reference: https://webpack.js.org/configuration/dev-server/
-  dev_server:
-    https: false
-    host: localhost
-    port: 3039
-    public: localhost:3039
-    hmr: true
-    # Inline should be set to true if using HMR
-    inline: true
-    overlay: true
-    compress: true
-    disable_host_check: true
-    use_local_ip: false
-    quiet: false
-    headers:
-      'Access-Control-Allow-Origin': '*'
-    watch_options:
-      ignored: '**/node_modules/**'
-    env_prefix: "AVO_WEBPACKER_DEV_SERVER"
+  # Production depends on precompilation of packs prior to booting for performance.
+  compile: false
+
+  # Extract and emit a css file
+  extract_css: true
+
+  # Cache manifest.json for performance
+  cache_manifest: true
 
 test:
   <<: *default

data/lib/avo.rb

@@ -1,20 +1,9 @@
-require_relative 'avo/configuration'
+require 'zeitwerk'
 require_relative 'avo/version'
+require_relative 'avo/engine' if defined?(Rails)
 
-require_relative 'avo/app/fields/field'
-
-require_relative 'avo/app/action'
-
-require_relative 'avo/app/filter'
-require_relative 'avo/app/filters/boolean_filter'
-require_relative 'avo/app/filters/select_filter'
-
-require_relative 'avo/app/fields_loader'
-require_relative 'avo/app/actions_loader'
-# require_relative 'avo/app/fields_loader_helper'
-require_relative 'avo/app/resource'
-
-require_relative 'avo/app/licensing/license_manager'
+loader = Zeitwerk::Loader.for_gem
+loader.setup
 
 module Avo
   ROOT_PATH = Pathname.new(File.join(__dir__, '..'))
@@ -31,4 +20,4 @@ module Avo
   end
 end
 
-require_relative 'avo/engine' if defined?(Rails)
+loader.eager_load

data/lib/avo/app.rb

@@ -0,0 +1,190 @@
+module Avo
+  class App
+    class_attribute :app, default: {
+      resources: [],
+      cache_store: nil
+    }
+    class_attribute :fields, default: []
+    class_attribute :request, default: nil
+    class_attribute :context, default: nil
+    class_attribute :license, default: nil
+
+    class << self
+  #     def load_controllers
+  #       BaseResource.descendants.each do |resource|
+  #         controller_name = "#{resource.to_s.gsub('Resource', '').pluralize}Controller"
+  #         puts controller_name.inspect
+  # #           eval <<DYNAMIC
+  # #   class #{controller_name} < Avo::ResourcesController
+  # #     # title :Person
+  # #     # attribute :name, String
+  # #     # ...or substitute other stuff in here.
+  # #   end
+  # # DYNAMIC
+
+  #         Avo.const_set(controller_name.to_sym, Class.new(Avo::ResourcesController))
+  #         # puts controller_name.inspect
+  #       end
+  #     end
+
+      def boot
+        init_fields
+
+        I18n.locale = Avo.configuration.language_code
+
+        if Rails.cache.class == ActiveSupport::Cache::NullStore
+          self.app[:cache_store] ||= ActiveSupport::Cache::MemoryStore.new
+        else
+          self.app[:cache_store] = Rails.cache
+        end
+      end
+
+      def init(request:, context:)
+        self.request = request
+        self.context = context
+
+        # Set the current host for ActiveStorage
+        ActiveStorage::Current.host = request.base_url
+
+        init_resources
+
+        self.license = Licensing::LicenseManager.new(Licensing::HQ.new(request).response).license
+      end
+
+      def cache_store
+        self.app[:cache_store]
+      end
+
+      # This method will find all fields available in the Avo::Fields namespace and add them to the fields class_variable array
+      # so later we can instantiate them on our resources.
+      #
+      # If the field has their `def_method` set up it will follow that convention, if not it will snake_case the name:
+      #
+      # Avo::Fields::TextField -> text
+      # Avo::Fields::DateTimeField -> date_time
+      def init_fields
+        Avo::Fields::BaseField.descendants.each do |class_name|
+          next if class_name.to_s == 'BaseField'
+
+          if class_name.to_s.end_with? 'Field'
+            load_field class_name.get_field_name, class_name
+          end
+        end
+      end
+
+      def load_field(method_name, klass)
+        self.fields.push(
+          name: method_name,
+          class: klass,
+        )
+
+        # Avo::Loaders::FieldsLoader.define_method method_name.to_sym do |*args, &block|
+        #   puts ['Avo::Loaders::FieldsLoader.define_method->', args, block.present?].inspect
+
+        #   if block.present?
+        #     puts '111->'.inspect
+        #     field = klass.new(args[0], **args[1] || {}, &block)
+        #   else
+        #     puts '222->'.inspect
+        #     field = klass.new(args[0], **args[1] || {})
+        #   end
+
+        #   puts field.inspect
+
+        #   self.bag.push field
+
+        #   # field
+        #   # if block.present?
+        #   #   field_class = klass::new(args[0], **args[1] || {}, &block)
+        #   # else
+        #   #   field_class = klass::new(args[0], **args[1] || {})
+        #   # end
+
+        #   # klass_entity.add_field(self, field_class)
+        # end
+      end
+
+      def init_resources
+        self.app[:resources] = BaseResource.descendants
+          .select do |resource|
+            resource != BaseResource
+          end
+          .map do |resource|
+            if resource.is_a? Class
+              resource.new
+            end
+          end
+      end
+
+      def get_resources
+        self.app[:resources]
+      end
+
+      # Returns the Avo resource by camelized name
+      #
+      # get_resource_by_name('User') => Avo::Resources::User
+      def get_resource(resource)
+        self.app[:resources].find do |available_resource|
+          "#{resource}Resource".safe_constantize == available_resource.class
+        end
+      end
+
+      # Returns the Avo resource by singular snake_cased name
+      #
+      # get_resource_by_name('user') => Avo::Resources::User
+      def get_resource_by_name(name)
+        self.get_resource name.singularize.camelize
+      end
+
+      # Returns the Avo resource by singular snake_cased name
+      #
+      # get_resource_by_name('User') => Avo::Resources::User
+      # get_resource_by_name(User) => Avo::Resources::User
+      def get_resource_by_model_name(name)
+        get_resources.find do |resource|
+          resource.model_class.model_name.name == name.to_s
+        end
+      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)
+        App.get_resources
+          .select do |resource|
+            Services::AuthorizationService.authorize user, resource.model, Avo.configuration.authorization_methods.stringify_keys['index'], raise_exception: false
+          end
+          .sort_by { |r| r.name }
+      end
+
+      def get_navigation_items(user = nil)
+        get_available_resources(user).select do |resource|
+          resource.model_class.present?
+        end
+      end
+
+      def draw_routes
+        # We should eager load all the classes so we find all descendants
+        Rails.application.eager_load!
+
+        Proc.new do
+          BaseResource.descendants
+            .select do |resource|
+              resource != :Resource
+            end
+            .map do |resource|
+              if resource.is_a? Class
+                route_key = resource.to_s.underscore.gsub('_resource', '').downcase.pluralize.to_sym
+
+                resources route_key
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/avo/base_action.rb

@@ -0,0 +1,123 @@
+module Avo
+  class BaseAction
+    class_attribute :name, default: self.class.to_s.demodulize.underscore.humanize(keep_id_suffix: true)
+    class_attribute :message
+    class_attribute :confirm_text
+    class_attribute :cancel_text
+    class_attribute :no_confirmation, default: false
+    class_attribute :fields_loader
+
+    attr_accessor :response
+    attr_accessor :model
+    attr_accessor :resource
+    attr_accessor :user
+
+    class << self
+      def fields(&block)
+        self.fields_loader ||= Avo::Loaders::FieldsLoader.new
+
+        yield(fields_loader)
+      end
+
+      def context
+        App.context
+      end
+    end
+
+    def initialize
+      self.class.message ||= I18n.t('avo.are_you_sure_you_want_to_run_this_option')
+      self.class.confirm_text ||= I18n.t('avo.run')
+      self.class.cancel_text ||= I18n.t('avo.cancel')
+
+      @response ||= {}
+      @response[:message_type] ||= :notice
+      @response[:message] ||= I18n.t('avo.action_ran_successfully')
+    end
+
+    def get_fields(view_type: :table)
+      get_field_definitions.map do |field|
+        field.hydrate(action: self, model: @model)
+      end
+      .select do |field|
+        field.can_see.present? ? field.can_see.call : true
+      end
+    end
+
+    def get_field_definitions
+      return [] if self.class.fields_loader.blank?
+
+      self.class.fields_loader.bag.map do |field|
+        field.hydrate(action: self)
+      end
+    end
+
+    def hydrate(model: nil, resource: nil, user: nil)
+      @model = model if model.present?
+      @resource = resource if resource.present?
+      @user = user if user.present?
+
+      self
+    end
+
+    def handle_action(request, models, raw_fields)
+      avo_fields = get_fields.map { |field| [field.id, field] }.to_h
+
+      if raw_fields.present?
+        fields = raw_fields.to_unsafe_h.map do |name, value|
+          [name, avo_fields[name.to_sym].resolve_attribute(value)]
+        end
+
+        fields = fields.to_h
+      else
+        fields = {}
+      end
+
+      result = self.handle request, models, fields
+
+      self
+    end
+
+    def param_id
+      self.class.to_s.demodulize.underscore.gsub '/', '_'
+    end
+
+    def succeed(text)
+      self.response[:message_type] = :notice
+      self.response[:message] = text
+
+      self
+    end
+
+    def fail(text)
+      self.response[:message_type] = :alert
+      self.response[:message] = text
+
+      self
+    end
+
+    def redirect_to(path = nil, &block)
+      self.response[:type] = :redirect
+      if block.present?
+        self.response[:path] = block
+      else
+        self.response[:path] = path
+      end
+
+      self
+    end
+
+    def reload
+      self.response[:type] = :reload
+
+      self
+    end
+
+    def download(path, filename)
+      self.response[:type] = :download
+      self.response[:path] = path
+      self.response[:filename] = filename
+
+      self
+    end
+  end
+end

data/lib/avo/base_resource.rb

@@ -0,0 +1,323 @@
+module Avo
+  class BaseResource
+    extend ActiveSupport::DescendantsTracker
+
+    attr_accessor :view
+    attr_accessor :model
+    attr_accessor :user
+    attr_accessor :params
+
+    class_attribute :id, default: :id
+    class_attribute :title, default: :id
+    class_attribute :search, default: [:id]
+    class_attribute :includes, default: []
+    class_attribute :translation_key
+    class_attribute :default_view_type, default: :table
+    class_attribute :devise_password_optional, default: false
+    class_attribute :fields_loader
+    class_attribute :actions_loader
+    class_attribute :filters_loader
+    class_attribute :grid_cover_loader
+    class_attribute :grid_title_loader
+    class_attribute :grid_body_loader
+
+    class << self
+      def fields(&block)
+        self.fields_loader ||= Avo::Loaders::FieldsLoader.new
+
+        yield(fields_loader)
+      end
+
+      def actions(&block)
+        self.actions_loader ||= Avo::Loaders::ActionsLoader.new
+
+        yield(actions_loader)
+      end
+
+      def filters(&block)
+        self.filters_loader ||= Avo::Loaders::FiltersLoader.new
+
+        yield(filters_loader)
+      end
+
+      def grid(&block)
+        self.grid_cover_loader ||= Avo::Loaders::FieldsLoader.new
+        self.grid_title_loader ||= Avo::Loaders::FieldsLoader.new
+        self.grid_body_loader ||= Avo::Loaders::FieldsLoader.new
+
+        yield(grid_cover_loader, grid_title_loader, grid_body_loader)
+      end
+
+      def context
+        App.context
+      end
+    end
+
+    def hydrate(model: nil, view: nil, user: nil, params: nil)
+      @view = view if view.present?
+      @user = user if user.present?
+      @params = params if params.present?
+
+      if model.present?
+        @model = model
+
+        hydrate_model_with_default_values if @view == :new
+      end
+
+      self
+    end
+
+    def get_fields(panel: nil, reflection: nil)
+      fields = get_field_definitions.select do |field|
+        field.send("show_on_#{@view.to_s}")
+      end
+      .select do |field|
+        field.can_see.present? ? field.can_see.call : true
+      end
+      .select do |field|
+        unless field.respond_to?(:foreign_key) &&
+          reflection.present? &&
+          reflection.respond_to?(:foreign_key) &&
+          reflection.foreign_key == field.foreign_key
+          true
+        end
+      end
+
+      if panel.present?
+        fields = fields.select do |field|
+          field.panel_name == panel
+        end
+      end
+
+      fields = fields.map do |field|
+        field.hydrate(model: @model, view: @view, resource: self)
+      end
+
+      fields
+    end
+
+    def get_grid_fields
+      return if self.class.grid_title_loader.blank?
+
+      card = {
+        cover: [*self.class.grid_cover_loader.bag],
+        title: [*self.class.grid_title_loader.bag],
+        body: [*self.class.grid_body_loader.bag],
+      }
+
+      card.each do |section, fields|
+        fields = fields.map do |field|
+          field.hydrate(model: @model, view: @view, resource: self)
+        end
+      end
+    end
+
+    def get_filters
+      return [] if self.class.filters_loader.blank?
+
+      self.class.filters_loader.bag
+    end
+
+    def get_actions
+      return [] if self.class.actions_loader.blank?
+
+      self.class.actions_loader.bag
+    end
+
+    def get_field_definitions
+      return [] if self.class.fields_loader.blank?
+
+      self.class.fields_loader.bag.map do |field|
+        field.hydrate(resource: self, panel_name: default_panel_name, user: user)
+      end
+    end
+
+    def default_panel_name
+      return @params[:related_name].capitalize if @params[:related_name].present?
+
+      case @view
+      when :show
+        I18n.t('avo.resource_details', item: self.name.downcase, title: model_title).upcase_first
+      when :edit
+        I18n.t('avo.update_item', item: self.name.downcase, title: model_title).upcase_first
+      when :new
+        I18n.t('avo.create_new_item', item: self.name.downcase).upcase_first
+      end
+    end
+
+    def panels
+      panels = [
+        {
+          name: default_panel_name,
+          type: :fields,
+          in_panel: true,
+        }
+      ]
+
+      panels
+    end
+
+    def model_class
+      return @model.class if @model.present?
+
+      self.class.name.demodulize.chomp('Resource').safe_constantize
+    end
+
+    def model_title
+      return @model.send title if @model.present?
+
+      name
+    end
+
+    def name
+      return @name if @name.present?
+
+      return I18n.t(@translation_key, count: 1).capitalize if @translation_key
+
+      self.class.name.demodulize.chomp('Resource').titlecase
+    end
+
+    def singular_name
+      name
+    end
+
+    def plural_name
+      return I18n.t(@translation_key, count: 2).capitalize if @translation_key
+
+      name.pluralize
+    end
+
+    def underscore_name
+      return @name if @name.present?
+
+      self.class.name.demodulize.underscore
+    end
+
+    def available_view_types
+      view_types = [:table]
+
+      view_types << :grid if get_grid_fields.present?
+
+      view_types
+    end
+
+    def route_key
+      model_class.model_name.route_key
+    end
+
+    def context
+      App.context
+    end
+
+    # def fields
+    #   raise NotImplementedError
+    # end
+
+    def query_search(query: '', via_resource_name: , via_resource_id:, user:)
+      # model_class = self.model
+
+      db_query = AuthorizationService.apply_policy(user, model_class)
+
+      if via_resource_name.present?
+        related_model = App.get_resource_by_name(via_resource_name).model
+
+        db_query = related_model.find(via_resource_id).public_send(self.plural_name.downcase)
+      end
+
+      new_query = []
+
+      [self.search].flatten.each_with_index do |search_by, index|
+        new_query.push 'or' if index != 0
+
+        new_query.push "text(#{search_by}) ILIKE '%#{query}%'"
+      end
+
+      db_query.where(new_query.join(' '))
+    end
+
+    def attached_file_fields
+      get_field_definitions.select do |field|
+        [Avo::Fields::FileField, Avo::Fields::FilesField].include? field.class
+      end
+    end
+
+    def fill_model(model, params)
+      # Map the received params to their actual fields
+      fields_by_database_id = self.get_field_definitions.map { |field| [field.database_id(model).to_s, field] }.to_h
+
+      params.each do |key, value|
+        field = fields_by_database_id[key]
+
+        next unless field
+
+        model = field.fill_field model, key, value
+      end
+
+      model
+    end
+
+    def authorization
+      Avo::Services::AuthorizationService.new(user, model)
+    end
+
+    def file_hash
+      content_to_be_hashed = ''
+
+      # resource file hash
+      resource_path = Rails.root.join('app', 'avo', 'resources', "#{name.underscore}.rb").to_s
+      if File.file? resource_path
+        content_to_be_hashed += File.read(resource_path)
+      end
+
+      # policy file hash
+      policy_path = Rails.root.join('app', 'policies', "#{name.underscore}_policy.rb").to_s
+      if File.file? policy_path
+        content_to_be_hashed += File.read(policy_path)
+      end
+
+      Digest::MD5.hexdigest(content_to_be_hashed)
+    end
+
+    def cache_hash(parent_model)
+      if parent_model.present?
+        [self.model, self.file_hash, parent_model]
+      else
+        [self.model, self.file_hash]
+      end
+    end
+
+    # For :new views we're hydrating the model with the values from the resource's default attribute.
+    # We will not overwrite any attributes that come pre-filled in the model.
+    def hydrate_model_with_default_values
+      default_values = get_fields.select do |field|
+        !field.computed
+      end
+      .map do |field|
+        id = field.id
+        value = field.value
+
+        if field.respond_to? :foreign_key
+          id = field.foreign_key.to_sym
+
+          reflection = @model._reflections[@params[:via_relation]]
+
+          if reflection.present? && reflection.foreign_key.present?
+            value = @params[:via_resource_id]
+          end
+        end
+
+        [id, value]
+      end
+      .to_h
+      .select do |id, value|
+        value.present?
+      end
+
+      default_values.each do |id, value|
+        if @model.send(id).nil?
+          @model.send("#{id}=", value)
+        end
+      end
+    end
+  end
+end