rails_console_pro 0.1.2 → 0.1.4

data/lib/rails_console_pro/queue_insights_result.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  class QueueInsightsResult
+    JobSummary = Struct.new(
+      :id,
+      :job_class,
+      :queue,
+      :args,
+      :enqueued_at,
+      :scheduled_at,
+      :attempts,
+      :error,
+      :metadata,
+      keyword_init: true
+    )
+
+    ExecutionSummary = Struct.new(
+      :id,
+      :job_class,
+      :queue,
+      :started_at,
+      :runtime_ms,
+      :worker,
+      :hostname,
+      :metadata,
+      keyword_init: true
+    )
+
+    attr_reader :adapter_name,
+                :adapter_type,
+                :enqueued_jobs,
+                :retry_jobs,
+                :recent_executions,
+                :meta,
+                :warnings,
+                :captured_at
+
+    def initialize(adapter_name:, adapter_type:, enqueued_jobs:, retry_jobs:, recent_executions:, meta: {}, warnings: [], captured_at: Time.current)
+      @adapter_name = adapter_name
+      @adapter_type = adapter_type
+      @enqueued_jobs = Array(enqueued_jobs)
+      @retry_jobs = Array(retry_jobs)
+      @recent_executions = Array(recent_executions)
+      @meta = meta || {}
+      @warnings = Array(warnings).compact
+      @captured_at = captured_at || Time.current
+    end
+
+    def adapter_label
+      [adapter_name, adapter_type].compact.uniq.join(" ")
+    end
+
+    def has_enqueued?
+      enqueued_jobs.any?
+    end
+
+    def has_retry_jobs?
+      retry_jobs.any?
+    end
+
+    def has_recent_executions?
+      recent_executions.any?
+    end
+
+    def empty?
+      !has_enqueued? && !has_retry_jobs? && !has_recent_executions?
+    end
+
+    def warnings?
+      warnings.any?
+    end
+
+    def total_enqueued
+      enqueued_jobs.size
+    end
+
+    def total_retry
+      retry_jobs.size
+    end
+
+    def total_recent
+      recent_executions.size
+    end
+
+    def totals
+      {
+        enqueued: total_enqueued,
+        retry: total_retry,
+        recent: total_recent
+      }
+    end
+
+    def with_overrides(overrides = {})
+      self.class.new(
+        adapter_name: overrides.fetch(:adapter_name, adapter_name),
+        adapter_type: overrides.fetch(:adapter_type, adapter_type),
+        enqueued_jobs: overrides.fetch(:enqueued_jobs, enqueued_jobs),
+        retry_jobs: overrides.fetch(:retry_jobs, retry_jobs),
+        recent_executions: overrides.fetch(:recent_executions, recent_executions),
+        meta: overrides.fetch(:meta, meta),
+        warnings: overrides.fetch(:warnings, warnings),
+        captured_at: overrides.fetch(:captured_at, captured_at)
+      )
+    end
+  end
+end
+
+
+

data/lib/rails_console_pro/serializers/compare_serializer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    # Serializer for CompareResult objects
+    class CompareSerializer < BaseSerializer
+      def serialize(compare_result)
+        result = {
+          timestamp: compare_result.timestamp&.iso8601,
+          total_strategies: compare_result.comparisons.size,
+          fastest: compare_result.fastest_name,
+          slowest: compare_result.slowest_name,
+          performance_ratio: compare_result.performance_ratio,
+          has_errors: compare_result.has_errors?,
+          error_count: compare_result.error_count,
+          total_queries: compare_result.total_queries,
+          comparisons: serialize_comparisons(compare_result.comparisons)
+        }
+        result[:winner] = serialize_comparison(compare_result.winner) if compare_result.winner
+        result
+      end
+
+      private
+
+      def serialize_comparisons(comparisons)
+        Array(comparisons).map { |c| serialize_comparison(c) }
+      end
+
+      def serialize_comparison(comparison)
+        return nil unless comparison
+
+        {
+          name: comparison.name,
+          duration_ms: comparison.duration_ms,
+          query_count: comparison.query_count,
+          memory_usage_kb: comparison.memory_usage_kb,
+          error: serialize_error(comparison.error),
+          sql_queries: serialize_sql_queries(comparison.sql_queries),
+          result: serialize_data(comparison.result)
+        }
+      end
+
+      def serialize_sql_queries(queries)
+        Array(queries).map do |query|
+          {
+            sql: query[:sql],
+            duration_ms: query[:duration_ms],
+            name: query[:name],
+            cached: query[:cached] || false
+          }
+        end
+      end
+
+      def serialize_error(error)
+        return nil unless error
+
+        {
+          class: error.class.name,
+          message: error.message,
+          backtrace: Array(error.backtrace).first(10)
+        }
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/introspect_serializer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    # Serializer for introspection results
+    class IntrospectSerializer < BaseSerializer
+      def serialize(result)
+        {
+          'type' => 'introspection',
+          'model' => result.model.name,
+          'callbacks' => serialize_callbacks(result.callbacks),
+          'enums' => serialize_enums(result.enums),
+          'concerns' => serialize_concerns(result.concerns),
+          'scopes' => serialize_scopes(result.scopes),
+          'validations' => serialize_validations(result.validations),
+          'lifecycle_hooks' => serialize_data(result.lifecycle_hooks),
+          'timestamp' => result.timestamp.iso8601,
+          'has_callbacks' => result.has_callbacks?,
+          'has_enums' => result.has_enums?,
+          'has_concerns' => result.has_concerns?,
+          'has_scopes' => result.has_scopes?,
+          'has_validations' => result.has_validations?
+        }
+      end
+
+      private
+
+      def serialize_callbacks(callbacks)
+        callbacks.transform_values do |chain|
+          chain.map do |callback|
+            {
+              'name' => callback[:name].to_s,
+              'kind' => callback[:kind].to_s,
+              'if' => serialize_condition(callback[:if]),
+              'unless' => serialize_condition(callback[:unless])
+            }.compact
+          end
+        end
+      end
+
+      def serialize_enums(enums)
+        enums.transform_values do |data|
+          {
+            'mapping' => data[:mapping],
+            'values' => data[:values],
+            'type' => data[:type].to_s
+          }
+        end
+      end
+
+      def serialize_concerns(concerns)
+        concerns.map do |concern|
+          {
+            'name' => concern[:name],
+            'type' => concern[:type].to_s,
+            'location' => serialize_location(concern[:location])
+          }.compact
+        end
+      end
+
+      def serialize_scopes(scopes)
+        scopes.transform_keys(&:to_s).transform_values do |data|
+          {
+            'sql' => data[:sql],
+            'values' => serialize_data(data[:values]),
+            'conditions' => data[:conditions]
+          }
+        end
+      end
+
+      def serialize_validations(validations)
+        validations.transform_keys(&:to_s).transform_values do |validators|
+          validators.map do |validator|
+            {
+              'type' => validator[:type],
+              'attributes' => validator[:attributes].map(&:to_s),
+              'options' => serialize_data(validator[:options]),
+              'conditions' => serialize_data(validator[:conditions])
+            }
+          end
+        end
+      end
+
+      def serialize_condition(condition)
+        return nil if condition.nil? || condition.empty?
+        condition.map(&:to_s)
+      end
+
+      def serialize_location(location)
+        return nil if location.nil?
+        {
+          'file' => location[:file],
+          'line' => location[:line]
+        }
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/profile_serializer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    # Serializer for ProfileResult objects
+    class ProfileSerializer < BaseSerializer
+      def serialize(profile)
+        {
+          label: profile.label,
+          duration_ms: profile.duration_ms,
+          total_sql_duration_ms: profile.total_sql_duration_ms,
+          query_count: profile.query_count,
+          read_query_count: profile.read_query_count,
+          write_query_count: profile.write_query_count,
+          cached_query_count: profile.cached_query_count,
+          instantiation_count: profile.instantiation_count,
+          cache_stats: serialize_cache(profile),
+          slow_queries: serialize_queries(profile.slow_queries),
+          duplicate_queries: serialize_duplicates(profile.duplicate_queries),
+          query_samples: serialize_queries(profile.query_samples),
+          error: serialize_error(profile.error),
+          started_at: profile.started_at&.iso8601,
+          finished_at: profile.finished_at&.iso8601,
+          result: serialize_data(profile.result)
+        }
+      end
+
+      private
+
+      def serialize_cache(profile)
+        {
+          hits: profile.cache_hits,
+          misses: profile.cache_misses,
+          writes: profile.cache_writes
+        }
+      end
+
+      def serialize_queries(queries)
+        Array(queries).map do |query|
+          {
+            sql: query.sql,
+            duration_ms: query.duration_ms,
+            cached: query.cached,
+            name: query.name,
+            binds: query.binds
+          }
+        end
+      end
+
+      def serialize_duplicates(duplicates)
+        Array(duplicates).map do |duplicate|
+          {
+            fingerprint: duplicate.fingerprint,
+            sql: duplicate.sql,
+            count: duplicate.count,
+            total_duration_ms: duplicate.total_duration_ms
+          }
+        end
+      end
+
+      def serialize_error(error)
+        return nil unless error
+
+        {
+          class: error.class.name,
+          message: error.message,
+          backtrace: Array(error.backtrace).first(10)
+        }
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/query_builder_serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    # Serializer for QueryBuilderResult objects
+    class QueryBuilderSerializer < BaseSerializer
+      def serialize(query_builder_result)
+        {
+          model_class: query_builder_result.model_class.name,
+          sql: query_builder_result.sql,
+          statistics: query_builder_result.statistics,
+          explain_result: serialize_explain(query_builder_result.explain_result)
+        }
+      end
+
+      private
+
+      def serialize_explain(explain_result)
+        return nil unless explain_result
+
+        if defined?(Serializers::ExplainSerializer)
+          Serializers::ExplainSerializer.serialize(explain_result, exporter)
+        else
+          {
+            sql: explain_result.sql,
+            execution_time: explain_result.execution_time,
+            indexes_used: explain_result.indexes_used,
+            recommendations: explain_result.recommendations
+          }
+        end
+      end
+    end
+  end
+end
+