motor-admin 0.1.9 → 0.1.14

data/lib/motor/api_query/build_json.rb

@@ -49,7 +49,8 @@ module Motor
 
         params[:fields].each do |key, fields|
           fields = fields.split(',') if fields.is_a?(String)
-          fields_hash = build_fields_hash(model, fields)
+          reflection_class = model.reflections[key]&.klass
+          fields_hash = build_fields_hash(reflection_class || model, fields)
 
           if key == model_name || model_name.split('/').last == key
             json_params.merge!(fields_hash)
@@ -68,7 +69,7 @@ module Motor
         fields.each_with_object(fields_hash) do |field, acc|
           if field.in?(columns)
             acc['only'] << field
-          else
+          elsif model.instance_methods.include?(field.to_sym)
             acc['methods'] << field
           end
         end

data/lib/motor/api_query/sort.rb

@@ -7,19 +7,39 @@ module Motor
 
       module_function
 
-      def call(rel, params)
-        return rel if params.blank?
+      def call(rel, param)
+        return rel if param.blank?
 
-        normalized_params = build_params(params)
+        arel_order = build_arel_order(rel.klass, param)
+        join_params = build_join_params(rel.klass, param)
 
-        rel.order(normalized_params)
+        rel.order(arel_order).left_joins(join_params)
       end
 
-      def build_params(param)
-        param.split(',').each_with_object({}) do |field, hash|
-          direction, name = field.match(FIELD_PARSE_REGEXP).captures
+      def build_join_params(_model, param)
+        param.split(',').each_with_object({}) do |field, result|
+          key = field[FIELD_PARSE_REGEXP, 2]
+          *path, _ = key.split('.')
 
-          hash[name] = direction.present? ? :desc : :asc
+          path.reduce(result) do |acc, fragment|
+            acc[fragment] = {}
+          end
+        end
+      end
+
+      def build_arel_order(model, param)
+        param.split(',').map do |field|
+          direction, key = field.match(FIELD_PARSE_REGEXP).captures
+          *path, field = key.split('.')
+
+          reflection_model =
+            path.reduce(model) do |acc, fragment|
+              acc.reflections[fragment].klass
+            end
+
+          arel_column = reflection_model.arel_table[field]
+
+          direction.present? ? arel_column.desc : arel_column.asc
         end
       end
     end

data/lib/motor/assets.rb

@@ -18,16 +18,16 @@ module Motor
       Motor::Admin.routes.url_helpers.motor_asset_path(manifest[path])
     end
 
-    def load_asset(filename)
+    def load_asset(filename, gzip: false)
       if Motor.development?
         load_from_dev_server(filename)
       else
-        load_from_disk(filename)
+        load_from_disk(filename, gzip: gzip)
       end
     end
 
-    def load_from_disk(filename)
-      filename += '.gz' if filename.match?(/\.(?:js|css)\z/)
+    def load_from_disk(filename, gzip:)
+      filename += '.gz' if gzip
 
       path = ASSETS_PATH.join(filename)
 

data/lib/motor/build_schema.rb

@@ -1,16 +1,61 @@
 # 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
+    module ColumnAccessTypes
+      ALL = [
+        READ_ONLY = 'read_only',
+        WRITE_ONLY = 'write_only',
+        READ_WRITE = 'read_write',
+        HIDDEN = 'hidden'
+      ].freeze
+    end
+
     SEARCHABLE_COLUMN_TYPES = %i[citext text string bitstring].freeze
 
+    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_SCOPE_TYPE = 'default'
+
+    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
@@ -21,3 +66,11 @@ module Motor
     end
   end
 end
+
+require_relative './build_schema/active_storage_attachment_schema'
+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'

data/lib/motor/build_schema/active_storage_attachment_schema.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    ACTIVE_STORAGE_ATTACHMENT_SCHEMA = {
+      name: 'active_storage/attachment',
+      slug: 'active_storage__attachments',
+      table_name: 'active_storage_attachments',
+      primary_key: 'id',
+      display_name: 'Attachments',
+      display_column: 'filename',
+      columns: [
+        {
+          name: 'id',
+          display_name: 'Id',
+          column_type: 'integer',
+          access_type: 'read_only',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'path',
+          display_name: 'Path',
+          column_type: 'string',
+          access_type: 'read_only',
+          default_value: nil,
+          validators: [],
+          virtual: true
+        },
+        {
+          name: 'name',
+          display_name: 'Name',
+          column_type: 'string',
+          access_type: 'read_write',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'record_type',
+          display_name: 'Record type',
+          column_type: 'string',
+          access_type: 'read_write',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'record_id',
+          display_name: 'Record',
+          column_type: 'integer',
+          access_type: 'read_write',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'file',
+          display_name: 'File',
+          column_type: 'file',
+          access_type: 'write_only',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'created_at',
+          display_name: 'Created at',
+          column_type: 'datetime',
+          access_type: 'read_only',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        }
+      ],
+      associations: [],
+      scopes: [],
+      actions: Motor::BuildSchema::DEFAULT_ACTIONS.reject { |e| e[:name] == 'edit' },
+      tabs: Motor::BuildSchema::DEFAULT_TABS,
+      visible: true
+    }.with_indifferent_access
+  end
+end

data/lib/motor/build_schema/find_display_column.rb

@@ -31,7 +31,7 @@ module Motor
         address
       ].freeze
 
-      DISPLAY_NAME_REGEXP = Regexp.new(Regexp.union(DISPLAY_NAMES), Regexp::IGNORECASE)
+      DISPLAY_NAME_REGEXP = Regexp.new(Regexp.union(DISPLAY_NAMES).source, Regexp::IGNORECASE)
 
       module_function
 

data/lib/motor/build_schema/load_from_rails.rb

@@ -3,73 +3,28 @@
 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
+        rescue StandardError, NotImplementedError => e
+          Rails.logger.error(e)
+
+          next
+        end.compact
       end
 
       def models
-        Rails.application.eager_load!
+        eager_load_models!
 
         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 -= [ActiveStorage::Blob] if defined?(ActiveStorage::Blob)
+        models -= [ActiveStorage::VariantRecord] if defined?(ActiveStorage::VariantRecord)
 
         models
       end
@@ -81,40 +36,120 @@ module Motor
       end
 
       def build_model_schema(model)
+        model_name = model.name
+
+        return Motor::BuildSchema::ACTIVE_STORAGE_ATTACHMENT_SCHEMA if model_name == 'ActiveStorage::Attachment'
+
         {
-          name: model.name.underscore,
+          name: model_name.underscore,
           slug: Utils.slugify(model),
           table_name: model.table_name,
+          class_name: model.name,
           primary_key: model.primary_key,
-          display_name: model.name.titleize.pluralize,
+          display_name: model_name.titleize.pluralize,
           display_column: FindDisplayColumn.call(model),
           columns: fetch_columns(model),
           associations: fetch_associations(model),
+          scopes: fetch_scopes(model),
           actions: DEFAULT_ACTIONS,
           tabs: DEFAULT_TABS,
           visible: true
         }.with_indifferent_access
       end
 
+      def fetch_scopes(model)
+        model.defined_scopes.map do |scope_name|
+          scope_name = scope_name.to_s
+
+          next if scope_name.starts_with?('with_attached')
+
+          {
+            name: scope_name,
+            display_name: scope_name.humanize,
+            scope_type: DEFAULT_SCOPE_TYPE,
+            visible: true,
+            preferences: {}
+          }
+        end.compact
+      end
+
       def fetch_columns(model)
         default_attrs = model.new.attributes
 
-        model.columns.map do |column|
+        reference_columns = fetch_reference_columns(model)
+
+        table_columns =
+          model.columns.map do |column|
+            next if reference_columns.find { |c| c[:name] == column.name }
+
+            {
+              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),
+              reference: nil,
+              virtual: false
+            }
+          end.compact
+
+        reference_columns + table_columns
+      end
+
+      def build_column(model, 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),
+          reference: fetch_reference(model, column.name),
+          virtual: false
+        }
+      end
+
+      def fetch_reference_columns(model)
+        default_attrs = model.new.attributes
+
+        model.reflections.map do |name, ref|
+          next if !ref.has_one? && !ref.belongs_to?
+
+          begin
+            ref.klass
+          rescue StandardError
+            next
+          end
+
+          column_name = ref.belongs_to? ? ref.foreign_key : name
+
+          next if ref.klass.name == 'ActiveStorage::Blob'
+
+          is_attachment = ref.klass.name == 'ActiveStorage::Attachment'
+
           {
-            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),
+            name: column_name,
+            display_name: column_name.humanize,
+            column_type: is_attachment ? 'file' : 'integer',
+            access_type: ref.belongs_to? || is_attachment ? ColumnAccessTypes::READ_WRITE : ColumnAccessTypes::READ_ONLY,
+            default_value: default_attrs[column_name],
+            validators: fetch_validators(model, column_name),
+            reference: {
+              name: name,
+              model_name: ref.klass.name.underscore,
+              reference_type: ref.belongs_to? ? 'belongs_to' : 'has_one',
+              foreign_key: ref.foreign_key,
+              polymorphic: ref.polymorphic? || is_attachment
+            },
             virtual: false
           }
-        end
+        end.compact
       end
 
       def fetch_associations(model)
         model.reflections.map do |name, ref|
-          next if ref.polymorphic? && !ref.belongs_to?
+          next if ref.has_one? || ref.belongs_to?
 
           begin
             ref.klass
@@ -122,37 +157,22 @@ module Motor
             next
           end
 
-          next if defined?(ActiveStorage::Blob) && ref.klass == ActiveStorage::Blob
+          model_class = ref.klass
+
+          next if model_class.name == '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),
+            model_name: model_class.name.underscore,
             foreign_key: ref.foreign_key,
-            polymorphic: ref.polymorphic?,
+            polymorphic: ref.polymorphic? || model_class.name == 'ActiveStorage::Attachment',
             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
@@ -171,6 +191,14 @@ module Motor
           end
         end.compact
       end
+
+      def eager_load_models!
+        if Rails::VERSION::MAJOR > 5 && defined?(Zeitwerk::Loader)
+          Zeitwerk::Loader.eager_load_all
+        else
+          Rails.application.eager_load!
+        end
+      end
     end
   end
 end