motor-admin 0.1.22 → 0.1.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a18eff1eb9149993c711610be8362de1818ae5abf9759cf06118d92cffb00c7b
-  data.tar.gz: 7cded1f7b12bcc38c10d0abe7df42bf66a412720cd884190d604ba70698d5fdd
+  metadata.gz: 2f18c5fae6ca2c70b739f68d0a9b45f456b6c9f9592b4c44d216210a067b2e33
+  data.tar.gz: 4a65316ecce576b9de027fe93ff14bf9307826269af771fbfc9a7bbf3699f051
 SHA512:
-  metadata.gz: 69a7380433550939c6efe7e7a7fb3b5aa7f4ba3d3adc3403c281579f86d7ab2b48c1767aadb059e4e58100cd12ae67a4df349a1d19bab65832421bc32bf57ea8
-  data.tar.gz: 34121a44946d91e89054c6cad50051af5c658e75660e0ba6ac64b77f394337f6d3ac4cbb3a03bb815c3ff6c6ed03b8f9023865fefe186bb1d02e80af68d7f732
+  metadata.gz: f51029e47fe84f67f34ced365523f2214c44986f241ad35a77405f067a556bbca8ca124cb09812b007a709101729ae3dfc35aa94284c46dbbf2f63a990459001
+  data.tar.gz: 555b5570c50258d3ee00a317795868cee3281e0d3675d894e25773f26977d21d40781b031a4e3835469fa580d39b3e1ba5b87f11dcad83986b0bd144f612bc5c

data/app/controllers/concerns/motor/wrap_io_params.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Motor
+  module WrapIoParams
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :wrap_io_params, only: %i[update create]
+    end
+
+    private
+
+    def wrap_io_params(hash = params)
+      hash.each do |key, value|
+        if key == 'io'
+          hash[key] = StringIO.new(value.encode('ISO-8859-1'))
+        elsif value.is_a?(ActionController::Parameters)
+          wrap_io_params(value)
+        end
+      end
+
+      hash
+    end
+  end
+end

data/app/controllers/motor/active_storage_attachments_controller.rb

@@ -2,16 +2,15 @@
 
 module Motor
   class ActiveStorageAttachmentsController < ApiBaseController
+    include Motor::WrapIoParams
+
     wrap_parameters :data, except: %i[include fields]
 
     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=")
-        @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)
-        )
+      if attachable?(@attachment.record)
+        @attachment.record.public_send(@attachment.name).attach(file_params)
 
         head :ok
       else
@@ -21,8 +20,21 @@ module Motor
 
     private
 
+    def attachable?(record)
+      record.respond_to?("#{@attachment.name}_attachment=") ||
+        record.respond_to?("#{@attachment.name}_attachments=")
+    end
+
+    def file_params
+      params.require(:data).require(:file).permit(:io, :filename).to_h
+    end
+
     def attachment_params
-      params.require(:data).except(:file).permit!
+      if params[:data].present?
+        params.require(:data).except(:file).permit!
+      else
+        {}
+      end
     end
   end
 end

data/app/controllers/motor/data_controller.rb

@@ -2,13 +2,14 @@
 
 module Motor
   class DataController < ApiBaseController
+    include Motor::WrapIoParams
+
     INSTANCE_VARIABLE_NAME = 'resource'
 
     wrap_parameters :data, except: %i[include fields]
 
     before_action :load_and_authorize_resource
     before_action :load_and_authorize_association
-    before_action :wrap_io_params
 
     def index
       @resources = Motor::ApiQuery.call(@resources, params)
@@ -27,12 +28,20 @@ module Motor
       @resource.save!
 
       render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params) }
+    rescue ActiveRecord::RecordInvalid
+      render json: { errors: @resource.errors }, status: :unprocessable_entity
+    rescue StandardError => e
+      render json: { errors: [e.message] }, status: :unprocessable_entity
     end
 
     def update
       @resource.update!(resource_params)
 
       render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params) }
+    rescue ActiveRecord::RecordInvalid
+      render json: { errors: @resource.errors }, status: :unprocessable_entity
+    rescue StandardError => e
+      render json: { errors: [e.message] }, status: :unprocessable_entity
     end
 
     def destroy
@@ -77,6 +86,8 @@ module Motor
         self,
         options
       ).load_and_authorize_resource
+    rescue StandardError => e
+      render json: { errors: [e.message] }, status: :unprocessable_entity
     end
 
     def load_and_authorize_association
@@ -96,6 +107,8 @@ module Motor
       else
         render json: { message: 'Unknown association' }, status: :not_found
       end
+    rescue StandardError => e
+      render json: { errors: [e.message] }, status: :unprocessable_entity
     end
 
     def resource_params
@@ -105,17 +118,5 @@ module Motor
         {}
       end
     end
-
-    def wrap_io_params(hash = params)
-      hash.each do |key, value|
-        if key == 'io'
-          hash[key] = StringIO.new(value.encode('ISO-8859-1'))
-        elsif value.is_a?(ActionController::Parameters)
-          wrap_io_params(value)
-        end
-      end
-
-      hash
-    end
   end
 end

data/lib/motor/admin.rb

@@ -14,6 +14,21 @@ module Motor
       end
     end
 
+    initializer 'motor.basic_auth' do
+      next if ENV['MOTOR_AUTH_PASSWORD'].blank?
+
+      config.middleware.use Rack::Auth::Basic do |username, password|
+        ActiveSupport::SecurityUtils.secure_compare(
+          ::Digest::SHA256.hexdigest(username),
+          ::Digest::SHA256.hexdigest(ENV['MOTOR_AUTH_USERNAME'].to_s)
+        ) &
+          ActiveSupport::SecurityUtils.secure_compare(
+            ::Digest::SHA256.hexdigest(password),
+            ::Digest::SHA256.hexdigest(ENV['MOTOR_AUTH_PASSWORD'].to_s)
+          )
+      end
+    end
+
     initializer 'motor.active_storage.extensions' do
       ActiveSupport.on_load(:active_storage_attachment) do
         ActiveStorage::Attachment.include(Motor::ActiveRecordUtils::ActiveStorageLinksExtension)

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,21 +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,
-              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
 
@@ -109,31 +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),
-            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, ref),
+          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?
@@ -160,30 +172,43 @@ module Motor
         end.compact
       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 }
+      def fetch_validators(model, column_name, reflection = nil)
+        validators =
+          if reflection&.belongs_to? && !reflection.options[:optional]
+            [{ required: true }]
           else
-            next
+            []
           end
+
+        validators += model.validators_on(column_name).map do |validator|
+          build_validator_hash(validator)
         end.compact
+
+        validators.uniq
+      end
+
+      def build_validator_hash(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 }
+        end
       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],
           {},
-          ->(_action) { true }
+          ->(_) { 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

@@ -4,7 +4,7 @@ module Motor
   module BuildSchema
     module PersistResourceConfigs
       RESOURCE_ATTRS = %w[display_name visible].freeze
-      COLUMN_ATTRS = %w[name display_name column_type access_type default_value virtual].freeze
+      COLUMN_ATTRS = %w[name display_name column_type access_type default_value virtual format].freeze
       ASSOCIATION_ATTRS = %w[name display_name visible].freeze
       SCOPE_ATTRS = %w[name display_name scope_type preferences visible].freeze
       ACTION_ATTRS = %w[name display_name action_type preferences visible].freeze
@@ -14,6 +14,7 @@ module Motor
         access_type: 'read_write',
         default_value: nil,
         reference: nil,
+        format: {},
         validators: []
       }.with_indifferent_access
 
@@ -76,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[configs_name],
+                                         existing_prefs.fetch(configs_name, []),
+                                         new_prefs.fetch(configs_name, []))
 
-        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.rb

@@ -5,6 +5,7 @@ module Motor
   end
 end
 
+require_relative './queries/render_sql_template'
 require_relative './queries/run_query'
 require_relative './queries/persistance'
 require_relative './queries/postgresql_exec_query'

data/lib/motor/queries/render_sql_template.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Motor
+  module Queries
+    module RenderSqlTemplate
+      SECTION_OPEN_REGEXP = /{{([#^])\s*(\w+)}}.*\z/m.freeze
+      VARIABLE_REGEXP = /{{\s*(\w+)\s*}}/m.freeze
+
+      module_function
+
+      def call(sql, variables)
+        result = render_sections(sql, variables)
+
+        interpolate_variables(result, variables)
+      end
+
+      def interpolate_variables(sql, variables)
+        selected_variables = []
+
+        rendered =
+          sql.gsub(VARIABLE_REGEXP) do
+            variable_name = Regexp.last_match[1]
+
+            index = selected_variables.index { |name, _| name == variable_name }
+            selected_variables << [variable_name, variables[variable_name]] unless index
+
+            "$#{selected_variables.size}"
+          end
+
+        [rendered, selected_variables]
+      end
+
+      def render_sections(sql, variables)
+        sql.sub(SECTION_OPEN_REGEXP) do |e|
+          variable_name = Regexp.last_match[2]
+          is_negative = Regexp.last_match[1] == '^'
+
+          _, content, rest = e.split(build_section_close_regexp(variable_name), 3)
+
+          is_present = variables[variable_name].present?
+
+          render_sections(is_present ^ is_negative ? content + rest.to_s : rest, variables)
+        end
+      end
+
+      def build_section_close_regexp(variable_name)
+        %r{{{[#^/]s*#{Regexp.escape(variable_name)}\s*}}}m
+      end
+    end
+  end
+end

data/lib/motor/queries/run_query.rb

@@ -3,8 +3,7 @@
 module Motor
   module Queries
     module RunQuery
-      DEFAULT_LIMIT = 1_000_000
-      INTERPOLATION_REGEXP = /{{(\w+)}}/.freeze
+      DEFAULT_LIMIT = 100_000
 
       QueryResult = Struct.new(:data, :columns, keyword_init: true)
 
@@ -14,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 ||= {}
 
@@ -22,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]
@@ -47,27 +62,40 @@ 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 = query.preferences.fetch(:variables, []).pluck(:name, :default_value)
-
-        sql =
-          query.sql_body.gsub(INTERPOLATION_REGEXP) do
-            index = variables.index { |name, _| name == (Regexp.last_match[1]) } + 1
+        variables = merge_variable_default_values(query.preferences.fetch(:variables, []), variables_hash)
 
-            "$#{index}"
-          end
+        sql, query_variables = RenderSqlTemplate.call(query.sql_body, variables)
 
-        attributes =
-          variables.map do |variable_name, default_value|
-            ActiveRecord::Relation::QueryAttribute.new(
-              variable_name,
-              variables_hash[variable_name] || default_value,
-              ActiveRecord::Type::Value.new
-            )
-          end
+        attributes = build_statement_attributes(query_variables)
 
         [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(
+            variable_name,
+            value,
+            ActiveRecord::Type::Value.new
+          )
+        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]
+        end
+      end
     end
   end
 end

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.22'
+  VERSION = '0.1.29'
 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-25b3270c536d4f5d15b5.css.gz": "main-25b3270c536d4f5d15b5.css.gz",
-  "main-25b3270c536d4f5d15b5.js.LICENSE.txt": "main-25b3270c536d4f5d15b5.js.LICENSE.txt",
-  "main-25b3270c536d4f5d15b5.js.gz": "main-25b3270c536d4f5d15b5.js.gz",
-  "main.css": "main-25b3270c536d4f5d15b5.css",
-  "main.js": "main-25b3270c536d4f5d15b5.js"
+  "main-482137e0bc1ba9f875dc.css.gz": "main-482137e0bc1ba9f875dc.css.gz",
+  "main-482137e0bc1ba9f875dc.js.LICENSE.txt": "main-482137e0bc1ba9f875dc.js.LICENSE.txt",
+  "main-482137e0bc1ba9f875dc.js.gz": "main-482137e0bc1ba9f875dc.js.gz",
+  "main.css": "main-482137e0bc1ba9f875dc.css",
+  "main.js": "main-482137e0bc1ba9f875dc.js"
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motor-admin
 version: !ruby/object:Gem::Version
-  version: 0.1.22
+  version: 0.1.29
 platform: ruby
 authors:
 - Pete Matsyburka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-04 00:00:00.000000000 Z
+date: 2021-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-filter
@@ -132,6 +132,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/controllers/concerns/motor/wrap_io_params.rb
 - app/controllers/motor/active_storage_attachments_controller.rb
 - app/controllers/motor/alerts_controller.rb
 - app/controllers/motor/api_base_controller.rb
@@ -208,13 +209,14 @@ files:
 - lib/motor/queries.rb
 - lib/motor/queries/persistance.rb
 - lib/motor/queries/postgresql_exec_query.rb
+- lib/motor/queries/render_sql_template.rb
 - lib/motor/queries/run_query.rb
 - lib/motor/tags.rb
 - lib/motor/ui_configs.rb
 - lib/motor/version.rb
 - ui/dist/fonts/ionicons.woff2
-- ui/dist/main-25b3270c536d4f5d15b5.css.gz
-- ui/dist/main-25b3270c536d4f5d15b5.js.gz
+- ui/dist/main-482137e0bc1ba9f875dc.css.gz
+- ui/dist/main-482137e0bc1ba9f875dc.js.gz
 - ui/dist/manifest.json
 homepage:
 licenses: