motor-admin-cstham8 0.4.35

data/lib/motor/queries/run_query.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+module Motor
+  module Queries
+    module RunQuery
+      DEFAULT_LIMIT = 100_000
+
+      QueryResult = Struct.new(:data, :columns, :error, keyword_init: true)
+
+      SUBQUERY_NAME = '__query__'
+
+      STATEMENT_VARIABLE_REGEXP = /\$\d+/.freeze
+      PG_ERROR_REGEXP = /\APG.+ERROR:/.freeze
+
+      RESERVED_VARIABLES = %w[current_user_id current_user_email].freeze
+
+      DATABASE_URL_VARIABLE_SUFFIX = '_database_url'
+      QUERY_VARIABLE_PREFIX = 'query_'
+
+      DB_LINK_VALIDATE_REGEXP = /(.*?)\s*\{\{\s*\w+_database_url\s*\}\}/i.freeze
+
+      UnknownDatabase = Class.new(StandardError)
+      UnsafeDatabaseUrlUsage = Class.new(StandardError)
+
+      module_function
+
+      # @param query [Motor::Query]
+      # @param variables_hash [Hash]
+      # @param limit [Integer]
+      # @param filters [Hash]
+      # @return [Motor::Queries::RunQuery::QueryResult]
+      def call!(query, variables_hash: nil, limit: nil, filters: nil)
+        variables_hash ||= {}
+        variables_hash = variables_hash.with_indifferent_access
+        limit ||= DEFAULT_LIMIT
+        filters ||= {}
+
+        result = execute_query(query, limit, variables_hash, filters)
+
+        QueryResult.new(data: result.rows, columns: build_columns_hash(result))
+      end
+
+      # @param query [Motor::Query]
+      # @param variables_hash [Hash]
+      # @param limit [Integer]
+      # @return [Motor::Queries::RunQuery::QueryResult]
+      def call(query, variables_hash: nil, limit: nil, filters: nil)
+        call!(query, variables_hash: variables_hash, limit: limit, filters: filters)
+      rescue ActiveRecord::StatementInvalid => e
+        QueryResult.new(error: build_error_message(e))
+      end
+
+      # @param exception [ActiveRecord::StatementInvalid]
+      # @return [String]
+      def build_error_message(exception)
+        exception.message.sub(PG_ERROR_REGEXP, '').strip.upcase_first
+      end
+
+      # @param query [Motor::Query]
+      # @param limit [Integer]
+      # @param variables_hash [Hash]
+      # @param filters [Hash]
+      # @return [ActiveRecord::Result]
+      def execute_query(query, limit, variables_hash, filters)
+        connection_class = fetch_connection_class(query)
+
+        statement = prepare_sql_statement(connection_class, query, limit, variables_hash, filters)
+
+        case connection_class.connection.class.name
+        when 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
+          PostgresqlExecQuery.call(connection_class.connection, statement)
+        else
+          statement = normalize_statement_for_sql(statement)
+
+          connection_class.connection.exec_query(*statement)
+        end
+      end
+
+      def validate_query!(sql)
+        return if sql.scan(DB_LINK_VALIDATE_REGEXP).flatten.all? { |line| line.ends_with?('dblink(') }
+
+        raise UnsafeDatabaseUrlUsage, 'Database URL variable is allowed only with dblink'
+      end
+
+      # @param result [ActiveRecord::Result]
+      # @return [Hash]
+      def build_columns_hash(result)
+        result.columns.map.with_index do |column_name, index|
+          column_type_class = result.column_types[column_name]
+
+          column_type = ActiveRecordUtils::Types.find_name_for_type(column_type_class) if column_type_class
+
+          column_type ||=
+            begin
+              not_nil_value = result.rows.reduce(nil) do |acc, row|
+                column = row[index]
+
+                break column unless column.nil?
+
+                acc
+              end
+
+              fetch_column_type_from_value(not_nil_value)
+            end
+
+          {
+            name: column_name,
+            display_name: column_name.humanize,
+            column_type: column_type,
+            is_array: column_type.class.to_s == 'ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array'
+          }
+        end
+      end
+
+      # @param value [Object]
+      # @return [String]
+      def fetch_column_type_from_value(value)
+        case value
+        when Integer
+          'integer'
+        when Float
+          'float'
+        when Time
+          'datetime'
+        when Date
+          'date'
+        when TrueClass, FalseClass
+          'boolean'
+        else
+          'string'
+        end
+      end
+
+      # @param connection_class [Class]
+      # @param query [Motor::Query]
+      # @param limit [Integer]
+      # @param variables_hash [Hash]
+      # @param filters [Hash]
+      # @return [Array]
+      def prepare_sql_statement(connection_class, query, limit, variables_hash, filters)
+        variables = merge_variable_default_values(query.preferences.fetch(:variables, []), variables_hash)
+
+        validate_query!(query.sql_body)
+
+        sql, query_variables = RenderSqlTemplate.call(query.sql_body, variables)
+        select_sql = build_select_sql(connection_class, sql, limit, filters)
+
+        attributes = build_statement_attributes(query_variables)
+
+        [select_sql, 'SQL', attributes]
+      end
+
+      # @param connection_class [Class]
+      # @param sql [String]
+      # @param limit [Number]
+      # @param filters [Hash]
+      # @return [String]
+      def build_select_sql(connection_class, sql, limit, filters)
+        sql = normalize_sql(sql)
+
+        subquery_sql = Arel.sql("(#{sql})").as(connection_class.connection.quote_column_name(SUBQUERY_NAME))
+
+        arel_filters = build_filters_arel(filters)
+
+        rel = connection_class.from(subquery_sql)
+                              .select(Arel::Table.new(SUBQUERY_NAME)[Arel.star])
+                              .where(arel_filters)
+
+        rel = rel.limit(limit.to_i) unless connection_class.connection.class.name.include?('SQLServerAdapter')
+
+        rel.to_sql
+      end
+
+      # @param filters [Hash]
+      # @return [Arel::Nodes, nil]
+      def build_filters_arel(filters)
+        return nil if filters.blank?
+
+        table = Arel::Table.new(SUBQUERY_NAME)
+
+        arel_filters = filters.map { |key, value| table[key].in(value) }
+
+        arel_filters[1..].reduce(arel_filters.first) { |acc, arel| acc.and(arel) }
+      end
+
+      # @param variables [Array<(String, Object)>]
+      # @return [Array<ActiveRecord::Relation::QueryAttribute>]
+      def build_statement_attributes(variables)
+        variables.map do |variable_name, value|
+          [value].flatten.map do |val|
+            val = fetch_variable_database_url(variable_name) if variable_name.ends_with?(DATABASE_URL_VARIABLE_SUFFIX)
+            val = fetch_query_data(variable_name) if variable_name.starts_with?(QUERY_VARIABLE_PREFIX)
+
+            ActiveRecord::Relation::QueryAttribute.new(
+              variable_name,
+              val,
+              ActiveRecord::Type::Value.new
+            )
+          end
+        end.flatten
+      end
+
+      def fetch_variable_database_url(variable_name)
+        class_name = variable_name.delete_suffix(DATABASE_URL_VARIABLE_SUFFIX).classify
+
+        Motor::DatabaseClasses.const_get(class_name).connection_db_config.url
+      rescue NameError
+        raise UnknownDatabase, "#{class_name} database is not defined"
+      end
+
+      def fetch_query_data(variable_name)
+        query = Motor::Query.find(variable_name.split('_').last)
+
+        result = Motor::Queries::RunQuery.call(query)
+        columns = result.columns.pluck(:name)
+
+        result.data.map { |row| columns.zip(row).to_h }.to_json
+      end
+
+      # @param array [Array]
+      # @return [Array]
+      def normalize_statement_for_sql(statement)
+        sql, _, attributes = statement
+
+        sql = ActiveRecord::Base.send(:replace_bind_variables,
+                                      sql.gsub(STATEMENT_VARIABLE_REGEXP, '?'),
+                                      attributes.map(&:value))
+
+        [sql, 'SQL', []]
+      end
+
+      def normalize_sql(sql)
+        sql.strip.delete_suffix(';').gsub(/\A\)+/, '').gsub(/\z\(+/, '')
+      end
+
+      # @param variable_configs [Array<Hash>]
+      # @param variables_hash [Hash]
+      # @return [Hash]
+      def merge_variable_default_values(variable_configs, variables_hash)
+        variable_configs.each_with_object(variables_hash.slice(*RESERVED_VARIABLES)) do |variable, acc|
+          next if RESERVED_VARIABLES.include?(variable[:name])
+
+          acc[variable[:name]] ||= variables_hash[variable[:name]] || variable[:default_value]
+        end
+      end
+
+      def fetch_connection_class(query)
+        database_name = query.preferences[:database]
+
+        return default_connection_class if database_name.blank? || database_name == 'default'
+
+        return default_connection_class if database_name == 'primary'
+
+        ar_configurations = ActiveRecord::Base.configurations.configurations
+                                              .find { |c| c.name == database_name && c.env_name == Rails.env }
+
+        if ar_configurations
+          fetch_ar_configurations_connection(database_name, ar_configurations)
+        else
+          Motor::DatabaseClasses.const_get(database_name.sub(/\A\d+/, '').parameterize.underscore.classify)
+        end
+      end
+
+      def fetch_ar_configurations_connection(database_name, ar_configurations)
+        Motor::DatabaseClasses.const_get(database_name.classify)
+      rescue NameError
+        klass = Class.new(ActiveRecord::Base)
+
+        Motor::DatabaseClasses.const_set(database_name.classify, klass)
+
+        klass.establish_connection(ar_configurations.name.to_sym)
+
+        klass
+      end
+
+      def find_connection_in_pool(database_name)
+        ActiveRecord::Base.connection_pool.connections.find do |conn|
+          conn.pool.db_config.name == database_name
+        end
+      end
+
+      def default_connection_class
+        'ResourceRecord'.safe_constantize ||
+          'ApplicationRecord'.safe_constantize ||
+          Class.new(ActiveRecord::Base).tap { |e| e.abstract_class = true }
+      end
+    end
+  end
+end

data/lib/motor/queries.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Motor
+  module Queries
+  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/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Motor
+  class Railtie < Rails::Railtie
+    railtie_name :motor_admin
+
+    rake_tasks do
+      Dir[Motor::PATH.join('./motor/tasks/**/*.rake')].each { |f| load f }
+    end
+  end
+end

data/lib/motor/resources/custom_sql_columns_cache.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Motor
+  module Resources
+    module CustomSqlColumnsCache
+      CACHE_STORE = ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
+
+      module_function
+
+      def call(sql)
+        CACHE_STORE.fetch(sql.hash) do
+          Queries::RunQuery.call(Query.new(sql_body: sql), limit: 0).columns || []
+        end
+      end
+    end
+  end
+end

data/lib/motor/resources/fetch_configured_model.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module Motor
+  module Resources
+    module FetchConfiguredModel
+      CACHE_HASH = ActiveSupport::HashWithIndifferentAccess.new
+
+      HAS_AND_BELONGS_TO_MANY_JOIN_MODEL_PREFIX = 'HABTM_'
+
+      module_function
+
+      def call(model, cache_key:)
+        configs = Motor::Configs::LoadFromCache.load_resources(cache_key: cache_key)
+
+        return model if model.name == 'ActiveStorage::Attachment'
+        return model if sti_model?(model)
+
+        maybe_fetch_from_cache(
+          model,
+          cache_key.to_s + model.object_id.to_s,
+          -> { build_configured_model_from_configs(model, configs) },
+          ->(klass) { configure_reflection_classes(klass, cache_key) }
+        )
+      end
+
+      def build_configured_model(model, config)
+        klass = Class.new(model)
+        klass.inheritance_column = nil if model.superclass.abstract_class
+
+        define_class_properties(klass, model)
+
+        define_columns_hash(klass, config)
+        define_default_scope(klass, config)
+        define_column_reflections(klass, config)
+        define_associations(klass, config)
+        define_searchable_columns_method(klass, config)
+
+        klass
+      end
+
+      def define_default_scope(klass, config)
+        return klass if config[:custom_sql].blank?
+
+        klass.instance_variable_set(:@__motor_custom_sql, config[:custom_sql].squish.delete_suffix(';'))
+
+        klass.instance_eval do
+          default_scope do
+            from(Arel.sql("(#{self.klass.instance_variable_get(:@__motor_custom_sql)})")
+                     .as(connection.quote_column_name(table_name)))
+          end
+        end
+
+        klass
+      end
+
+      def define_audited_class(klass)
+        default_audit_class = Audited.audit_class
+
+        Audited.audit_class = 'Motor::Audit'
+
+        klass.audited
+
+        klass
+      ensure
+        Audited.audit_class = default_audit_class
+      end
+
+      def define_class_properties(klass, model)
+        define_audited_class(klass) unless [Audited::Audit, Motor::Audit].include?(model)
+
+        klass.table_name = model.table_name
+
+        klass.instance_variable_set(:@__motor_model_name, model.name)
+
+        klass.instance_eval do
+          def name
+            @__motor_model_name
+          end
+
+          def inspect
+            super.gsub(/\#<Class:0x\w+>/, name)
+          end
+
+          def to_s
+            super.gsub(/\#<Class:0x\w+>/, name)
+          end
+
+          def anonymous?
+            true
+          end
+        end
+
+        klass
+      end
+
+      def define_searchable_columns_method(klass, config)
+        return if config[:searchable_columns].blank?
+
+        klass.instance_variable_set(:@__motor_searchable_columns, config[:searchable_columns])
+
+        klass.instance_eval do
+          def motor_searchable_columns
+            @__motor_searchable_columns
+          end
+        end
+      end
+
+      def define_columns_hash(klass, config)
+        return klass if config[:custom_sql].blank?
+
+        columns = Resources::CustomSqlColumnsCache.call(config[:custom_sql])
+
+        columns_hash =
+          columns.each_with_object({}) do |column, acc|
+            acc[column[:name]] =
+              ActiveRecord::ConnectionAdapters::Column.new(
+                column[:name],
+                nil,
+                ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: column[:column_type],
+                                                                      type: column[:column_type].to_sym)
+              )
+          end
+
+        klass.instance_variable_set(:@__motor_custom_sql_columns_hash, columns_hash)
+
+        # rubocop:disable Naming/MemoizedInstanceVariableName
+        klass.instance_eval do
+          def columns_hash
+            @__motor__columns_hash ||= @__motor_custom_sql_columns_hash.merge(super)
+          end
+        end
+        # rubocop:enable Naming/MemoizedInstanceVariableName
+      end
+
+      def define_column_reflections(klass, config)
+        config.fetch(:columns, []).each do |column|
+          reference = column[:reference]
+
+          next if reference.blank?
+
+          if reference[:reference_type] == 'belongs_to'
+            define_belongs_to_reflection(klass, reference)
+          else
+            define_has_one_reflection(klass, reference)
+          end
+        end
+      end
+
+      def define_belongs_to_reflection(klass, config)
+        klass.belongs_to(config[:name].to_sym,
+                         class_name: config[:model_name]&.classify,
+                         foreign_key: config[:foreign_key],
+                         polymorphic: config[:polymorphic],
+                         primary_key: config[:primary_key],
+                         optional: true)
+      end
+
+      def define_has_one_reflection(klass, config)
+        if config[:model_name] == 'active_storage/attachment'
+          klass.has_one_attached(config[:name].delete_suffix('_attachment').to_sym)
+        else
+          options = {
+            **klass.reflections[config[:name]]&.options.to_h,
+            class_name: config[:model_name].classify,
+            foreign_key: config[:foreign_key],
+            primary_key: config[:primary_key],
+            **config[:options].to_h
+          }.symbolize_keys
+
+          klass.has_one(config[:name].to_sym, **options)
+        end
+      end
+
+      def configure_reflection_classes(klass, cache_key)
+        klass._reflections.each do |key, ref|
+          next unless configure_reflection_class?(ref)
+
+          ref_dup = ref.dup
+
+          if ref.klass.name == klass.name
+            ref_dup.instance_variable_set(:@klass, klass)
+          else
+            ref_dup.instance_variable_set(:@klass, call(ref.klass, cache_key: cache_key))
+          end
+
+          klass.reflections[key] = ref_dup
+        end
+
+        klass._reflections = klass.reflections
+
+        klass
+      end
+
+      def define_associations(klass, config)
+        config.fetch(:associations, []).each do |association|
+          next unless association[:virtual]
+
+          options = normalize_association_params(association)
+
+          filters = options.delete(:filters)
+
+          define_association(klass, association[:name], options, filters)
+        end
+      end
+
+      def define_association(klass, name, options, filters)
+        if options[:class_name] == 'ActiveStorage::Attachment'
+          klass.has_many_attached name.delete_suffix('_attachments').to_sym
+        elsif filters.present?
+          klass.has_many(name.to_sym, lambda {
+                                        Motor::ApiQuery::Filter.apply_filters(all, filters).distinct
+                                      }, **options.symbolize_keys)
+        else
+          klass.has_many(name.to_sym, **options.symbolize_keys)
+        end
+      end
+
+      def normalize_association_params(params)
+        options = params.slice(:foreign_key, :primary_key).merge(dependent: :destroy)
+
+        options[:class_name] = params[:model_name].classify
+        options[:as] = params[:foreign_key].delete_suffix('_id') if params[:polymorphic]
+
+        options.merge(params[:options] || {})
+      end
+
+      def maybe_fetch_from_cache(model, cache_key, miss_cache_block, postprocess_block)
+        return miss_cache_block.call unless cache_key
+
+        if CACHE_HASH[model.name] && CACHE_HASH[model.name][:key] == cache_key
+          CACHE_HASH[model.name][:value]
+        else
+          result = miss_cache_block.call
+
+          CACHE_HASH[model.name] = { key: cache_key, value: result }
+
+          postprocess_block.call(result)
+        end
+      end
+
+      def build_configured_model_from_configs(model, configs)
+        resource_config = configs.find { |r| r.name == model.name.underscore }
+
+        if resource_config
+          build_configured_model(model, resource_config.preferences)
+        else
+          define_class_properties(Class.new(model), model)
+        end
+      end
+
+      def configure_reflection_class?(ref)
+        begin
+          return false unless ref.klass
+        rescue StandardError
+          return false
+        end
+
+        return false if ref.klass.anonymous?
+        return false if ref.klass.name.demodulize.starts_with?(HAS_AND_BELONGS_TO_MANY_JOIN_MODEL_PREFIX)
+
+        true
+      end
+
+      def sti_model?(model)
+        !model.superclass.abstract_class && model.columns_hash[model.inheritance_column.to_s]
+      end
+    end
+  end
+end