motor-admin 0.1.9

data/lib/motor/api_query/paginate.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module Paginate
+      MAX_PER_PAGE = 500
+
+      module_function
+
+      def call(rel, params)
+        params ||= {}
+
+        rel = rel.limit([MAX_PER_PAGE, (params[:limit] || MAX_PER_PAGE).to_i].min)
+        rel.offset(params[:offset].to_i)
+      end
+    end
+  end
+end

data/lib/motor/api_query/search.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module Search
+      SELECT_COLUMNS_AMOUNT = 2
+      COLUMN_TYPES = BuildSchema::SEARCHABLE_COLUMN_TYPES
+      ID_REGEXP = /\A\d+\z/.freeze
+
+      module_function
+
+      def call(rel, keyword)
+        return rel if keyword.blank?
+
+        filters = fetch_filters(rel, keyword)
+
+        arel_where = build_arel_or_query(filters)
+
+        rel.where(arel_where)
+      end
+
+      def fetch_filters(rel, keyword)
+        arel_filters = []
+
+        klass = rel.klass
+        arel_table = klass.arel_table
+
+        arel_filters << arel_table[klass.primary_key].eq(keyword) if keyword.match?(ID_REGEXP)
+
+        string_column_names = find_searchable_columns(klass)
+        selected_columns = select_columns(string_column_names)
+
+        selected_columns.each { |name| arel_filters << arel_table[name].matches("%#{keyword}%") }
+
+        arel_filters
+      end
+
+      def build_arel_or_query(filter_array)
+        filter_array.reduce(nil) do |acc, filter|
+          next acc = filter unless acc
+
+          acc.or(filter)
+        end
+      end
+
+      def select_columns(columns)
+        selected_columns =
+          columns.select do |name|
+            BuildSchema::FindDisplayColumn::DISPLAY_NAME_REGEXP.match?(name)
+          end.presence
+
+        selected_columns ||= columns.first(SELECT_COLUMNS_AMOUNT)
+
+        selected_columns
+      end
+
+      def find_searchable_columns(model)
+        model.columns.map do |column|
+          next unless column.type.in?(COLUMN_TYPES)
+
+          has_inclusion_validator =
+            model.validators_on(column.name).any? do |e|
+              e.is_a?(ActiveModel::Validations::InclusionValidator)
+            end
+
+          next if has_inclusion_validator
+
+          column.name
+        end.compact
+      end
+    end
+  end
+end

data/lib/motor/api_query/sort.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module Sort
+      FIELD_PARSE_REGEXP = /\A(-)?(.*)\z/.freeze
+
+      module_function
+
+      def call(rel, params)
+        return rel if params.blank?
+
+        normalized_params = build_params(params)
+
+        rel.order(normalized_params)
+      end
+
+      def build_params(param)
+        param.split(',').each_with_object({}) do |field, hash|
+          direction, name = field.match(FIELD_PARSE_REGEXP).captures
+
+          hash[name] = direction.present? ? :desc : :asc
+        end
+      end
+    end
+  end
+end

data/lib/motor/assets.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Motor
+  module Assets
+    InvalidPathError = Class.new(StandardError)
+
+    ASSETS_PATH = Pathname.new(__dir__).join('../../ui/dist')
+    MANIFEST_PATH = ASSETS_PATH.join('manifest.json')
+    DEV_SERVER_URL = 'http://localhost:9090/'
+
+    module_function
+
+    def manifest
+      JSON.parse(MANIFEST_PATH.read)
+    end
+
+    def asset_path(path)
+      Motor::Admin.routes.url_helpers.motor_asset_path(manifest[path])
+    end
+
+    def load_asset(filename)
+      if Motor.development?
+        load_from_dev_server(filename)
+      else
+        load_from_disk(filename)
+      end
+    end
+
+    def load_from_disk(filename)
+      filename += '.gz' if filename.match?(/\.(?:js|css)\z/)
+
+      path = ASSETS_PATH.join(filename)
+
+      raise InvalidPathError unless path.to_s.starts_with?(ASSETS_PATH.to_s)
+
+      path.read
+    end
+
+    def load_from_dev_server(filename)
+      uri = URI(DEV_SERVER_URL + filename)
+
+      Net::HTTP.get_response(uri).body
+    end
+  end
+end

data/lib/motor/build_schema.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative './build_schema/load_from_rails'
+require_relative './build_schema/find_display_column'
+require_relative './build_schema/persist_resource_configs'
+require_relative './build_schema/reorder_schema'
+require_relative './build_schema/merge_schema_configs'
+require_relative './build_schema/utils'
+
+module Motor
+  module BuildSchema
+    SEARCHABLE_COLUMN_TYPES = %i[citext text string bitstring].freeze
+
+    module_function
+
+    def call
+      schema = LoadFromRails.call
+      schema = MergeSchemaConfigs.call(schema)
+
+      ReorderSchema.call(schema)
+    end
+  end
+end

data/lib/motor/build_schema/find_display_column.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module FindDisplayColumn
+      DISPLAY_NAMES = %w[
+        name
+        full_name
+        fullname
+        last_name
+        lastname
+        first_name
+        firstname
+        fname
+        lname
+        sname
+        phone
+        phone_number
+        email
+        domain
+        phone
+        company
+        filename
+        file_name
+        title
+        url
+        make
+        brand
+        manufacturer
+        model
+        address
+      ].freeze
+
+      DISPLAY_NAME_REGEXP = Regexp.new(Regexp.union(DISPLAY_NAMES), Regexp::IGNORECASE)
+
+      module_function
+
+      def call(model)
+        column_names = fetch_column_names(model)
+
+        select_column_name(column_names)
+      end
+
+      def select_column_name(column_names)
+        name   = column_names.find { |column_name| column_name.in?(DISPLAY_NAMES) }
+        name ||= column_names.find { |column_name| column_name.match?(DISPLAY_NAME_REGEXP) }
+
+        name
+      end
+
+      def fetch_column_names(model)
+        model.columns.map do |column|
+          next unless column.type.in?(BuildSchema::SEARCHABLE_COLUMN_TYPES)
+
+          column.name
+        end.compact
+      end
+    end
+  end
+end

data/lib/motor/build_schema/load_from_rails.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module LoadFromRails
+      module ColumnAccessTypes
+        ALL = [
+          READ_ONLY = 'read_only',
+          WRITE_ONLY = 'write_only',
+          READ_WRITE = 'read_write',
+          HIDDEN = 'hidden'
+        ].freeze
+      end
+
+      COLUMN_NAME_ACCESS_TYPES = {
+        id: ColumnAccessTypes::READ_ONLY,
+        created_at: ColumnAccessTypes::READ_ONLY,
+        updated_at: ColumnAccessTypes::READ_ONLY,
+        deleted_at: ColumnAccessTypes::READ_ONLY
+      }.with_indifferent_access.freeze
+
+      DEFAULT_ACTIONS = [
+        {
+          name: 'create',
+          display_name: 'Create',
+          action_type: 'default',
+          preferences: {},
+          visible: true
+        },
+        {
+          name: 'edit',
+          display_name: 'Edit',
+          action_type: 'default',
+          preferences: {},
+          visible: true
+        },
+        {
+          name: 'remove',
+          display_name: 'Remove',
+          action_type: 'default',
+          preferences: {},
+          visible: true
+        }
+      ].freeze
+
+      DEFAULT_TABS = [
+        {
+          name: 'summary',
+          display_name: 'Summary',
+          tab_type: 'default',
+          preferences: {},
+          visible: true
+        }
+      ].freeze
+
+      module_function
+
+      def call
+        models.map do |model|
+          build_model_schema(model)
+        end
+      end
+
+      def models
+        Rails.application.eager_load!
+
+        models = load_descendants(ActiveRecord::Base).uniq
+        models = models.reject(&:abstract_class)
+
+        models -= Motor::ApplicationRecord.descendants
+        models -= [ActiveRecord::SchemaMigration] if defined?(ActiveRecord::SchemaMigration)
+        models -= [ActiveStorage::Blob, ActiveStorage::VariantRecord] if defined?(ActiveStorage::Blob)
+
+        models
+      end
+
+      def load_descendants(model)
+        model.descendants + model.descendants.flat_map do |klass|
+          load_descendants(klass)
+        end
+      end
+
+      def build_model_schema(model)
+        {
+          name: model.name.underscore,
+          slug: Utils.slugify(model),
+          table_name: model.table_name,
+          primary_key: model.primary_key,
+          display_name: model.name.titleize.pluralize,
+          display_column: FindDisplayColumn.call(model),
+          columns: fetch_columns(model),
+          associations: fetch_associations(model),
+          actions: DEFAULT_ACTIONS,
+          tabs: DEFAULT_TABS,
+          visible: true
+        }.with_indifferent_access
+      end
+
+      def fetch_columns(model)
+        default_attrs = model.new.attributes
+
+        model.columns.map do |column|
+          {
+            name: column.name,
+            display_name: column.name.humanize,
+            column_type: ActiveRecordUtils::Types::UNIFIED_TYPES[column.type.to_s] || column.type.to_s,
+            access_type: COLUMN_NAME_ACCESS_TYPES.fetch(column.name, ColumnAccessTypes::READ_WRITE),
+            default_value: default_attrs[column.name],
+            validators: fetch_validators(model, column.name),
+            virtual: false
+          }
+        end
+      end
+
+      def fetch_associations(model)
+        model.reflections.map do |name, ref|
+          next if ref.polymorphic? && !ref.belongs_to?
+
+          begin
+            ref.klass
+          rescue StandardError
+            next
+          end
+
+          next if defined?(ActiveStorage::Blob) && ref.klass == ActiveStorage::Blob
+
+          {
+            name: name,
+            display_name: name.humanize,
+            slug: name.underscore,
+            model_name: ref.klass.name.underscore,
+            model_slug: Utils.slugify(ref.klass),
+            association_type: fetch_association_type(ref),
+            foreign_key: ref.foreign_key,
+            polymorphic: ref.polymorphic?,
+            visible: true
+          }
+        end.compact
+      end
+
+      def fetch_association_type(association)
+        case association.association_class.to_s
+        when 'ActiveRecord::Associations::HasManyAssociation',
+             'ActiveRecord::Associations::HasManyThroughAssociation'
+          'has_many'
+        when 'ActiveRecord::Associations::HasOneAssociation',
+             'ActiveRecord::Associations::HasOneThroughAssociation'
+          'has_one'
+        when 'ActiveRecord::Associations::BelongsToAssociation'
+          'belongs_to'
+        else
+          raise ArgumentError, 'Unknown association type'
+        end
+      end
+
+      def fetch_validators(model, column_name)
+        model.validators_on(column_name).map do |validator|
+          case validator
+          when ActiveModel::Validations::InclusionValidator
+            { includes: validator.send(:delimiter) }
+          when ActiveRecord::Validations::PresenceValidator
+            { required: true }
+          when ActiveModel::Validations::FormatValidator
+            { format: JsRegex.new(validator.options[:with]).to_h.slice(:source, :options) }
+          when ActiveRecord::Validations::LengthValidator
+            { length: validator.options }
+          when ActiveModel::Validations::NumericalityValidator
+            { numeric: validator.options }
+          else
+            next
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/motor/build_schema/merge_schema_configs.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module MergeSchemaConfigs
+      RESOURCE_ATTRS = PersistResourceConfigs::RESOURCE_ATTRS
+      COLUMN_DEFAULTS = PersistResourceConfigs::COLUMN_DEFAULTS
+      ACTION_DEFAULTS = PersistResourceConfigs::ACTION_DEFAULTS
+      TAB_DEFAULTS = PersistResourceConfigs::TAB_DEFAULTS
+
+      module_function
+
+      # @param schema [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def call(schema)
+        configs = load_configs
+
+        schema.map do |model|
+          merge_model(model, configs.fetch(model[:name], {}))
+        end
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_model(model, configs)
+        updated_model = model.merge(configs.slice(*RESOURCE_ATTRS))
+
+        updated_model[:columns] = merge_by_name(
+          model[:columns],
+          configs[:columns],
+          COLUMN_DEFAULTS
+        )
+
+        updated_model[:associations] = merge_by_name(
+          model[:associations],
+          configs[:associations]
+        )
+
+        updated_model[:actions] = merge_by_name(
+          model[:actions],
+          configs[:actions],
+          ACTION_DEFAULTS
+        )
+
+        updated_model[:tabs] = merge_by_name(
+          model[:tabs],
+          configs[:tabs],
+          ACTION_DEFAULTS
+        )
+
+        updated_model
+      end
+
+      # @param defaults [Array<HashWithIndifferentAccess>]
+      # @param configs [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def merge_by_name(defaults, configs, default_attrs = {})
+        return defaults if configs.blank?
+
+        (defaults.pluck(:name) + configs.pluck(:name)).uniq.map do |name|
+          config_item = configs.find { |e| e[:name] == name } || {}
+          default_item = defaults.find { |e| e[:name] == name } || default_attrs
+
+          default_item.merge(config_item)
+        end
+      end
+
+      # @return [HashWithIndifferentAccess<String, HashWithIndifferentAccess>]
+      def load_configs
+        Motor::Resource.all.each_with_object(HashWithIndifferentAccess.new) do |resource, acc|
+          acc[resource.name] = resource.preferences
+        end
+      end
+    end
+  end
+end