motor-admin 0.1.27 → 0.1.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 696c86b5eeeb132c8216b7662999f671926e0fc9149d74ccb66feb2d120e5e4a
-  data.tar.gz: 00550110edef326dc5d063577bf29a936e4890031f02f9412fb03b431c310476
+  metadata.gz: 5799ce999fa943638fa7c4d655400c1418ee80977bf47f64a71e6d5c496d02de
+  data.tar.gz: da99ec7b1c48708d983b663a7f9cb79b6d0e270b2fc9f5538a8121cfabdbc209
 SHA512:
-  metadata.gz: c91831b3bca03a0f490fee511dbdb70e0635f7e639778b24df48fc248858ead0de39c0744659f388cfcacaa960f01e4d5622b32bab6d1ca1528819aa2da721d1
-  data.tar.gz: 010d5465953944c84189ac3c0a458df1ade18175bf2999faf4259e002fb37d7a49ec6428da755c6bac4de5efaa41193c955d0ca7f72c1bc0dc6c35a61210bd65
+  metadata.gz: c5fc31a79b01ad0e716700a7c3daed980b293d13081294d1013918cce6f4d24cf4c104e0c44144cde225fd3b1ce07253f9b3ddaf44f1eca2252a01ff9124c52e
+  data.tar.gz: efca3a6d85ce6e33c83a63f3cd5addbd75b2baf099bd96c5efbac40445520a7725d68a5c3d0564792f06bdf12fed8958b13a6189047303d3c77f7f0af0ff0bd4

data/app/controllers/motor/active_storage_attachments_controller.rb

@@ -7,7 +7,7 @@ module Motor
     load_and_authorize_resource :attachment, class: 'ActiveStorage::Attachment', parent: false
 
     def create
-      if @attachment.record.respond_to?("#{@attachment.name}_attachment=") || @attachment.record.respond_to?("#{@attachment.name}_attachments=")
+      if attachable?(@attachment.record)
         @attachment.record.public_send(@attachment.name).attach(
           io: StringIO.new(params.dig(:data, :file, :io).to_s.encode('ISO-8859-1')),
           filename: params.dig(:data, :file, :filename)
@@ -21,6 +21,11 @@ module Motor
 
     private
 
+    def attachable?(record)
+      record.respond_to?("#{@attachment.name}_attachment=") ||
+        record.respond_to?("#{@attachment.name}_attachments=")
+    end
+
     def attachment_params
       params.require(:data).except(:file).permit!
     end

data/lib/motor/active_record_utils/types.rb

@@ -21,8 +21,7 @@ module Motor
         'text' => 'string',
         'citext' => 'string',
         'jsonb' => 'json',
-        'timestamp' => 'datetime',
-        'money' => 'currency'
+        'timestamp' => 'datetime'
       }.freeze
 
       module_function

data/lib/motor/api_query/build_json.rb

@@ -29,9 +29,11 @@ module Motor
               hash = {}
 
               path.split('.').reduce(hash) do |acc, part|
-                acc[part] = {}
+                acc_hash = {}
 
-                acc[part]
+                acc[part] = acc_hash
+
+                acc_hash
               end
 
               accumulator.deep_merge(hash)
@@ -45,20 +47,25 @@ module Motor
         return if params[:fields].blank?
 
         model = rel.is_a?(ActiveRecord::Relation) ? rel.klass : rel.class
-        model_name = model.name.underscore
 
         params[:fields].each do |key, fields|
           fields = fields.split(',') if fields.is_a?(String)
 
-          if key == model_name || model_name.split('/').last == key
-            json_params.merge!(build_fields_hash(model, fields))
-          else
-            hash = find_key_in_params(json_params, key)
+          merge_fields_params!(key, fields, json_params, model)
+        end
+      end
 
-            fields_hash = build_fields_hash(model.reflections[key]&.klass, fields)
+      def merge_fields_params!(key, fields, json_params, model)
+        model_name = model.name.underscore
 
-            hash.merge!(fields_hash)
-          end
+        if key == model_name || model_name.split('/').last == key
+          json_params.merge!(build_fields_hash(model, fields))
+        else
+          hash = find_key_in_params(json_params, key)
+
+          fields_hash = build_fields_hash(model.reflections[key]&.klass, fields)
+
+          hash.merge!(fields_hash)
         end
       end
 

data/lib/motor/api_query/sort.rb

@@ -22,7 +22,11 @@ module Motor
           *path, _ = key.split('.')
 
           path.reduce(result) do |acc, fragment|
-            acc[fragment] = {}
+            hash = {}
+
+            acc[fragment] = hash
+
+            hash
           end
         end
       end

data/lib/motor/build_schema/load_from_rails.rb

@@ -3,6 +3,8 @@
 module Motor
   module BuildSchema
     module LoadFromRails
+      MUTEX = Mutex.new
+
       module_function
 
       def call
@@ -82,22 +84,26 @@ module Motor
           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,
-              format: {},
-              virtual: false
-            }
+            build_table_column(column, model, default_attrs)
           end.compact
 
         reference_columns + table_columns
       end
 
+      def build_table_column(column, model, default_attrs)
+        {
+          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,
+          format: {},
+          virtual: false
+        }
+      end
+
       def fetch_reference_columns(model)
         default_attrs = model.new.attributes
 
@@ -110,32 +116,36 @@ module Motor
             next
           end
 
-          column_name = ref.belongs_to? ? ref.foreign_key.to_s : 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: 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),
-            format: {},
-            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
-          }
+          build_reflection_column(name, model, ref, default_attrs)
         end.compact
       end
 
+      def build_reflection_column(name, model, ref, default_attrs)
+        column_name = ref.belongs_to? ? ref.foreign_key.to_s : name
+        is_attachment = ref.klass.name == 'ActiveStorage::Attachment'
+        access_type = ref.belongs_to? || is_attachment ? ColumnAccessTypes::READ_WRITE : ColumnAccessTypes::READ_ONLY
+
+        {
+          name: column_name,
+          display_name: column_name.humanize,
+          column_type: is_attachment ? 'file' : 'integer',
+          access_type: access_type,
+          default_value: default_attrs[column_name],
+          validators: fetch_validators(model, column_name),
+          format: {},
+          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
+
       def fetch_associations(model)
         model.reflections.map do |name, ref|
           next if ref.has_one? || ref.belongs_to?
@@ -182,10 +192,12 @@ module Motor
       end
 
       def eager_load_models!
-        if Rails::VERSION::MAJOR > 5 && defined?(Zeitwerk::Loader)
-          Zeitwerk::Loader.eager_load_all
-        else
-          Rails.application.eager_load!
+        MUTEX.synchronize do
+          if Rails::VERSION::MAJOR > 5 && defined?(Zeitwerk::Loader)
+            Zeitwerk::Loader.eager_load_all
+          else
+            Rails.application.eager_load!
+          end
         end
       end
     end

data/lib/motor/build_schema/merge_schema_configs.rb

@@ -27,40 +27,81 @@ module Motor
       def merge_model(model, configs)
         updated_model = model.merge(configs.slice(*RESOURCE_ATTRS))
 
-        updated_model[:associations] = merge_by_name(
+        merge_actions!(updated_model, configs)
+        merge_assiciations!(updated_model, configs)
+        merge_columns!(updated_model, configs)
+        merge_tabs!(updated_model, configs)
+        merge_scopes!(updated_model, configs)
+
+        updated_model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_assiciations!(model, configs)
+        model[:associations] = merge_by_name(
           model[:associations],
           configs[:associations],
           {},
           ->(_) { true }
         )
 
-        updated_model[:columns] = merge_by_name(
+        model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_columns!(model, configs)
+        model[:columns] = merge_by_name(
           model[:columns],
           configs[:columns],
           COLUMN_DEFAULTS,
           ->(scope) { !scope[:virtual] }
         )
 
-        updated_model[:actions] = merge_by_name(
+        model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_actions!(model, configs)
+        model[:actions] = merge_by_name(
           model[:actions],
           configs[:actions],
           ACTION_DEFAULTS
         )
 
-        updated_model[:tabs] = merge_by_name(
+        model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_tabs!(model, configs)
+        model[:tabs] = merge_by_name(
           model[:tabs],
           configs[:tabs],
           TAB_DEFAULTS
         )
 
-        updated_model[:scopes] = merge_by_name(
+        model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_scopes!(model, configs)
+        model[:scopes] = merge_by_name(
           model[:scopes],
           configs[:scopes],
           SCOPE_DEFAULTS,
           ->(scope) { scope[:scope_type] != 'filter' }
         )
 
-        updated_model
+        model
       end
 
       # @param defaults [Array<HashWithIndifferentAccess>]

data/lib/motor/build_schema/persist_resource_configs.rb

@@ -77,47 +77,26 @@ module Motor
         normalized_preferences = existing_prefs.merge(normalized_preferences)
         normalized_preferences = reject_default(default_prefs, normalized_preferences)
 
-        if new_prefs[:columns].present?
-          normalized_preferences[:columns] = normalize_columns(
-            default_prefs[:columns],
-            existing_prefs.fetch(:columns, []),
-            new_prefs.fetch(:columns, [])
-          )
-        end
+        normalize_configs!(normalized_preferences, :columns, default_prefs, existing_prefs, new_prefs)
+        normalize_configs!(normalized_preferences, :associations, default_prefs, existing_prefs, new_prefs)
+        normalize_configs!(normalized_preferences, :actions, default_prefs, existing_prefs, new_prefs)
+        normalize_configs!(normalized_preferences, :tabs, default_prefs, existing_prefs, new_prefs)
+        normalize_configs!(normalized_preferences, :scopes, default_prefs, existing_prefs, new_prefs)
 
-        if new_prefs[:associations].present?
-          normalized_preferences[:associations] = normalize_associations(
-            default_prefs[:associations],
-            existing_prefs.fetch(:associations, []),
-            new_prefs.fetch(:associations, [])
-          )
-        end
+        normalized_preferences.compact
+      end
 
-        if new_prefs[:actions].present?
-          normalized_preferences[:actions] = normalize_actions(
-            default_prefs[:actions],
-            existing_prefs.fetch(:actions, []),
-            new_prefs.fetch(:actions, [])
-          )
-        end
+      def normalize_configs!(preferences, configs_name, default_prefs, existing_prefs, new_prefs)
+        return preferences if new_prefs[configs_name].blank?
 
-        if new_prefs[:tabs].present?
-          normalized_preferences[:tabs] = normalize_tabs(
-            default_prefs[:tabs],
-            existing_prefs.fetch(:tabs, []),
-            new_prefs.fetch(:tabs, [])
-          )
-        end
+        normalized_configs = public_send("normalize_#{configs_name}",
+                                         default_prefs[:actions],
+                                         existing_prefs.fetch(:actions, []),
+                                         new_prefs.fetch(:actions, []))
 
-        if new_prefs[:scopes].present?
-          normalized_preferences[:scopes] = normalize_scopes(
-            default_prefs[:scopes],
-            existing_prefs.fetch(:scopes, []),
-            new_prefs.fetch(:scopes, [])
-          )
-        end
+        preferences[configs_name] = normalized_configs
 
-        normalized_preferences.compact
+        preferences
       end
 
       # @param default_columns [Array<HashWithIndifferentAccess>]

data/lib/motor/build_schema/reorder_schema.rb

@@ -23,21 +23,29 @@ module Motor
 
       schema = sort_by_name(schema, configs['resources.order'])
 
-      schema.map do |model|
-        columns_order = configs["resources.#{model[:name]}.columns.order"]
-        associations_order = configs["resources.#{model[:name]}.associations.order"]
-        actions_order = configs["resources.#{model[:name]}.actions.order"]
-        tabs_order = configs["resources.#{model[:name]}.tabs.order"]
-        scopes_order = configs["resources.#{model[:name]}.scopes.order"]
+      schema.map { |model| reorder_model(model, configs) }
+    end
 
-        model.merge(
-          columns: sort_by_name(sort_columns(model[:columns]), columns_order, sort_alphabetically: false),
-          associations: sort_by_name(model[:associations], associations_order),
-          actions: sort_by_name(model[:actions], actions_order, sort_alphabetically: false),
-          tabs: sort_by_name(model[:tabs], tabs_order, sort_alphabetically: false),
-          scopes: sort_by_name(model[:scopes], scopes_order)
-        )
-      end
+    def reorder_model(model, configs)
+      order_configs = build_order_configs(model[:name], configs)
+
+      model.merge(
+        columns: sort_by_name(sort_columns(model[:columns]), order_configs[:columns], sort_alphabetically: false),
+        associations: sort_by_name(model[:associations], order_configs[:associations]),
+        actions: sort_by_name(model[:actions], order_configs[:actions], sort_alphabetically: false),
+        tabs: sort_by_name(model[:tabs], order_configs[:tabs], sort_alphabetically: false),
+        scopes: sort_by_name(model[:scopes], order_configs[:scopes])
+      )
+    end
+
+    def build_order_configs(model_name, configs)
+      {
+        columns: configs["resources.#{model_name}.columns.order"],
+        associations: configs["resources.#{model_name}.associations.order"],
+        actions: configs["resources.#{model_name}.actions.order"],
+        tabs: configs["resources.#{model_name}.tabs.order"],
+        scopes: configs["resources.#{model_name}.scopes.order"]
+      }
     end
 
     # @param list [Array<HashWithIndifferentAccess>]

data/lib/motor/queries/run_query.rb

@@ -3,7 +3,7 @@
 module Motor
   module Queries
     module RunQuery
-      DEFAULT_LIMIT = 1_000_000
+      DEFAULT_LIMIT = 100_000
 
       QueryResult = Struct.new(:data, :columns, keyword_init: true)
 
@@ -13,6 +13,10 @@ module Motor
 
       module_function
 
+      # @param query [Motor::Query]
+      # @param variables_hash [Hash]
+      # @param limit [Integer]
+      # @return [Motor::Queries::RunQuery::QueryResult]
       def call(query, variables_hash: nil, limit: DEFAULT_LIMIT)
         variables_hash ||= {}
 
@@ -21,15 +25,27 @@ module Motor
         QueryResult.new(data: result.rows, columns: build_columns_hash(result))
       end
 
+      # @param query [Motor::Query]
+      # @param limit [Integer]
+      # @param variables_hash [Hash]
+      # @return [ActiveRecord::Result]
       def execute_query(query, limit, variables_hash)
+        result = nil
         statement = prepare_sql_statement(query, limit, variables_hash)
 
-        case ActiveRecord::Base.connection
-        when ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-          PostgresqlExecQuery.call(ActiveRecord::Base.connection, statement)
-        else
-          ActiveRecord::Base.connection.exec_query(*statement)
+        ActiveRecord::Base.transaction do
+          result =
+            case ActiveRecord::Base.connection
+            when ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+              PostgresqlExecQuery.call(ActiveRecord::Base.connection, statement)
+            else
+              ActiveRecord::Base.connection.exec_query(*statement)
+            end
+
+          raise ActiveRecord::Rollback
         end
+
+        result
       end
 
       # @param result [ActiveRecord::Result]
@@ -46,6 +62,10 @@ module Motor
         end
       end
 
+      # @param query [Motor::Query]
+      # @param limit [Integer]
+      # @param variables_hash [Hash]
+      # @return [Array]
       def prepare_sql_statement(query, limit, variables_hash)
         variables = merge_variable_default_values(query.preferences.fetch(:variables, []), variables_hash)
 
@@ -56,6 +76,8 @@ module Motor
         [format(WITH_STATEMENT_TEMPLATE, sql_body: sql.strip.gsub(/;\z/, ''), limit: limit), 'SQL', attributes]
       end
 
+      # @param variables [Array<(String, Object)>]
+      # @return [Array<ActiveRecord::Relation::QueryAttribute>]
       def build_statement_attributes(variables)
         variables.map do |variable_name, value|
           ActiveRecord::Relation::QueryAttribute.new(
@@ -66,6 +88,9 @@ module Motor
         end
       end
 
+      # @param variable_configs [Array<Hash>]
+      # @param variable_hash [Hash]
+      # @return [Hash]
       def merge_variable_default_values(variable_configs, variables_hash)
         variable_configs.each_with_object({}) do |variable, acc|
           acc[variable[:name]] = variables_hash[variable[:name]] || variable[:default_value]

data/lib/motor/ui_configs.rb

@@ -27,22 +27,42 @@ module Motor
       {
         base_path: Motor::Admin.routes.url_helpers.motor_path,
         schema: Motor::BuildSchema.call,
-        header_links: Motor::Config.find_by(key: 'header.links')&.value || [],
-        queries: Motor::Query.all.active.preload(:tags)
-                             .as_json(only: %i[id name updated_at],
-                                      include: { tags: { only: %i[id name] } }),
-        dashboards: Motor::Dashboard.all.active.preload(:tags)
-                                    .as_json(only: %i[id title updated_at],
-                                             include: { tags: { only: %i[id name] } }),
-        alerts: Motor::Alert.all.active.preload(:tags)
-                            .as_json(only: %i[id name is_enabled updated_at],
-                                     include: { tags: { only: %i[id name] } }),
-        forms: Motor::Form.all.active.preload(:tags)
-                          .as_json(only: %i[id name updated_at],
-                                   include: { tags: { only: %i[id name] } })
+        header_links: header_links_data_hash,
+        queries: queries_data_hash,
+        dashboards: dashboards_data_hash,
+        alerts: alerts_data_hash,
+        forms: forms_data_hash
       }
     end
 
+    def header_links_data_hash
+      Motor::Config.find_by(key: 'header.links')&.value || []
+    end
+
+    def queries_data_hash
+      Motor::Query.all.active.preload(:tags)
+                  .as_json(only: %i[id name updated_at],
+                           include: { tags: { only: %i[id name] } })
+    end
+
+    def dashboards_data_hash
+      Motor::Dashboard.all.active.preload(:tags)
+                      .as_json(only: %i[id title updated_at],
+                               include: { tags: { only: %i[id name] } })
+    end
+
+    def alerts_data_hash
+      Motor::Alert.all.active.preload(:tags)
+                  .as_json(only: %i[id name is_enabled updated_at],
+                           include: { tags: { only: %i[id name] } })
+    end
+
+    def forms_data_hash
+      Motor::Form.all.active.preload(:tags)
+                 .as_json(only: %i[id name updated_at],
+                          include: { tags: { only: %i[id name] } })
+    end
+
     # @return [String]
     def cache_key
       ActiveRecord::Base.connection.execute(

data/lib/motor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Motor
-  VERSION = '0.1.27'
+  VERSION = '0.1.28'
 end

data/ui/dist/manifest.json

@@ -5,9 +5,9 @@
   "fonts/ionicons.ttf?v=3.0.0-alpha.3": "fonts/ionicons.ttf",
   "fonts/ionicons.woff2?v=3.0.0-alpha.3": "fonts/ionicons.woff2",
   "fonts/ionicons.woff?v=3.0.0-alpha.3": "fonts/ionicons.woff",
-  "main-d6c1f237d3568a138874.css.gz": "main-d6c1f237d3568a138874.css.gz",
-  "main-d6c1f237d3568a138874.js.LICENSE.txt": "main-d6c1f237d3568a138874.js.LICENSE.txt",
-  "main-d6c1f237d3568a138874.js.gz": "main-d6c1f237d3568a138874.js.gz",
-  "main.css": "main-d6c1f237d3568a138874.css",
-  "main.js": "main-d6c1f237d3568a138874.js"
+  "main-4da1a5102d7bc66aefd0.css.gz": "main-4da1a5102d7bc66aefd0.css.gz",
+  "main-4da1a5102d7bc66aefd0.js.LICENSE.txt": "main-4da1a5102d7bc66aefd0.js.LICENSE.txt",
+  "main-4da1a5102d7bc66aefd0.js.gz": "main-4da1a5102d7bc66aefd0.js.gz",
+  "main.css": "main-4da1a5102d7bc66aefd0.css",
+  "main.js": "main-4da1a5102d7bc66aefd0.js"
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motor-admin
 version: !ruby/object:Gem::Version
-  version: 0.1.27
+  version: 0.1.28
 platform: ruby
 authors:
 - Pete Matsyburka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-05 00:00:00.000000000 Z
+date: 2021-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-filter
@@ -214,8 +214,8 @@ files:
 - lib/motor/ui_configs.rb
 - lib/motor/version.rb
 - ui/dist/fonts/ionicons.woff2
-- ui/dist/main-d6c1f237d3568a138874.css.gz
-- ui/dist/main-d6c1f237d3568a138874.js.gz
+- ui/dist/main-4da1a5102d7bc66aefd0.css.gz
+- ui/dist/main-4da1a5102d7bc66aefd0.js.gz
 - ui/dist/manifest.json
 homepage:
 licenses: