dbwatcher 1.0.0 → 1.1.1

data/lib/dbwatcher/services/analyzers/session_data_processor.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module Analyzers
+      # Handles session data processing and change iteration
+      #
+      # This service extracts and processes individual changes from session data,
+      # providing a clean interface for iterating over table changes.
+      #
+      # @example
+      #   processor = SessionDataProcessor.new(session)
+      #   processor.process_changes do |table_name, change, tables|
+      #     # Process each change
+      #   end
+      class SessionDataProcessor < BaseService
+        # Initialize with session
+        #
+        # @param session [Session] session to process
+        def initialize(session)
+          @session = session
+          super()
+        end
+
+        # Process all changes in the session
+        #
+        # @return [Hash] tables hash with processed data
+        def call
+          log_service_start "Processing session changes", session_context
+          start_time = Time.current
+
+          tables = {}
+
+          process_changes do |table_name, change, tables_ref|
+            yield(table_name, change, tables_ref) if block_given?
+          end
+
+          log_service_completion(start_time, { tables_found: tables.keys.length })
+          tables
+        end
+
+        # Process changes with block
+        #
+        # @yield [table_name, change, tables] for each change
+        # @return [Hash] tables hash
+        def process_changes
+          return {} unless session&.changes.respond_to?(:each)
+
+          tables = {}
+
+          session.changes.each do |change|
+            table_name = extract_table_name(change)
+            next unless table_name
+
+            yield(table_name, change, tables) if block_given?
+          end
+
+          tables
+        end
+
+        # Extract table name from change data
+        #
+        # @param change [Hash] change data
+        # @return [String, nil] table name or nil
+        def extract_table_name(change)
+          return nil unless change.is_a?(Hash)
+
+          change[:table_name]
+        end
+
+        # Extract session tables that were modified
+        #
+        # @return [Array<String>] unique table names
+        def extract_session_tables
+          return [] unless session&.changes
+
+          session.changes.map do |change|
+            extract_table_name(change)
+          end.compact.uniq
+        end
+
+        private
+
+        attr_reader :session
+
+        # Build context for logging
+        #
+        # @return [Hash] session context
+        def session_context
+          {
+            session_id: session&.id,
+            changes_count: session&.changes&.count || 0
+          }
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/analyzers/table_summary_builder.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Dbwatcher
+  module Services
+    module Analyzers
+      # Builds comprehensive table summaries from session data
+      #
+      # This service aggregates table operations, captures sample records,
+      # and builds complete table summaries for analysis and visualization.
+      #
+      # @example
+      #   builder = TableSummaryBuilder.new(session)
+      #   summary = builder.call
+      #   # => { "users" => { columns: Set, sample_record: {}, operations: {}, changes: [] } }
+      class TableSummaryBuilder < BaseService
+        # Initialize with session
+        #
+        # @param session [Session] session to analyze
+        def initialize(session)
+          super()
+          @session = session
+          @processor = SessionDataProcessor.new(session)
+        end
+
+        # Build table summaries from session data
+        #
+        # @return [Hash] table summaries keyed by table name
+        def call
+          log_service_start("session_id=#{session.id} changes_count=#{session.changes.length}")
+
+          start_time = Time.now
+          tables = build_tables_data
+          log_service_completion(start_time, result_context(tables))
+          tables
+        end
+
+        private
+
+        attr_reader :session, :processor
+
+        # Initialize table data structure
+        #
+        # @param tables [Hash] tables collection
+        # @param table_name [String] table name
+        def initialize_table_data(tables, table_name)
+          tables[table_name] ||= {
+            name: table_name,
+            columns: Set.new,
+            sample_record: nil,
+            total_operations: 0,
+            operations: { insert: 0, update: 0, delete: 0 },
+            changes: []
+          }
+        end
+
+        # Update table data with change information
+        #
+        # @param table_data [Hash] table data structure
+        # @param change [Hash] change data
+        def update_table_data(table_data, change)
+          # Extract and normalize operation
+          operation = extract_operation(change)
+
+          # Update counters
+          table_data[:total_operations] += 1
+          table_data[:operations][operation] = table_data[:operations].fetch(operation, 0) + 1
+
+          # Add the actual change data for view display
+          table_data[:changes] << change
+        end
+
+        # Update sample record to capture all columns
+        #
+        # @param table_data [Hash] table data structure
+        # @param change [Hash] change data
+        def update_sample_record(table_data, change)
+          # Try multiple possible data sources for record snapshot
+          sample_data = extract_record_data(change)
+          return unless sample_data.is_a?(Hash)
+
+          # Initialize or merge sample record
+          if table_data[:sample_record].nil?
+            table_data[:sample_record] = sample_data.dup
+          else
+            # Merge to capture all possible columns from different records
+            table_data[:sample_record].merge!(sample_data)
+          end
+
+          # Track all columns seen in this table
+          sample_data.each_key { |key| table_data[:columns].add(key.to_s) }
+        end
+
+        # Extract operation type from change data
+        #
+        # @param change [Hash] change data
+        # @return [Symbol] operation type (:insert, :update, :delete)
+        def extract_operation(change)
+          operation_str = change[:operation]&.to_s&.downcase
+
+          case operation_str
+          when "insert" then :insert
+          when "update" then :update
+          when "delete" then :delete
+          else
+            log_warning("Unknown operation type: #{operation_str || "nil"}")
+            :unknown
+          end
+        end
+
+        # Log a warning message
+        #
+        # @param message [String] warning message
+        def log_warning(message)
+          puts "[WARNING] #{service_name}: #{message}"
+        end
+
+        # Extract record data from various change formats
+        #
+        # @param change [Hash] change data
+        # @return [Hash, nil] record data or nil
+        def extract_record_data(change)
+          # Try record_snapshot first (most reliable)
+          return change[:record_snapshot] if change[:record_snapshot].is_a?(Hash)
+
+          # Fallback to building from changes array
+          build_record_from_changes(change[:changes]) if change[:changes].is_a?(Array)
+        end
+
+        # Build record data from changes array
+        #
+        # @param changes [Array] array of column changes
+        # @return [Hash] constructed record data
+        def build_record_from_changes(changes)
+          record = {}
+
+          changes.each do |column_change|
+            next unless column_change.is_a?(Hash) && column_change[:column]
+
+            # Use new_value if available, otherwise old_value
+            value = column_change[:new_value] || column_change[:old_value]
+            record[column_change[:column]] = value
+          end
+
+          record
+        end
+
+        # Get service name for logging
+        #
+        # @return [String] service name
+        def service_name
+          "TableSummaryBuilder"
+        end
+
+        # Build tables data by processing all changes
+        def build_tables_data
+          tables = {}
+
+          processor.process_changes do |table_name, change, _tables|
+            initialize_table_data(tables, table_name)
+            update_table_data(tables[table_name], change)
+            update_sample_record(tables[table_name], change)
+          end
+
+          filter_and_format_tables(tables)
+        end
+
+        # Filter out empty tables and format operations for view compatibility
+        def filter_and_format_tables(tables)
+          # Filter out tables with no operations
+          tables.reject! { |_, data| data[:total_operations].zero? }
+
+          # Convert operation counts to string keys for view compatibility
+          tables.each_value do |data|
+            data[:operations] = format_operations(data[:operations])
+          end
+
+          tables
+        end
+
+        # Format operations hash with string keys and remove zero counts
+        def format_operations(operations)
+          formatted = {
+            "INSERT" => operations[:insert] || 0,
+            "UPDATE" => operations[:update] || 0,
+            "DELETE" => operations[:delete] || 0
+          }
+          formatted.reject { |_, count| count.zero? }
+        end
+
+        # Build result context for logging
+        def result_context(tables)
+          {
+            tables_analyzed: tables.keys.length,
+            total_operations: tables.values.sum { |t| t[:total_operations] }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/api/base_api_service.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module Api
+      # Base class for API data services
+      #
+      # Provides common functionality for API endpoints including
+      # session handling, caching, and error handling.
+      class BaseApiService < BaseService
+        attr_reader :session, :params
+
+        def initialize(session, params = {})
+          @session = session
+          @params = params
+          super()
+        end
+
+        protected
+
+        # Build cache key for session-based data
+        #
+        # @param suffix [String] additional cache key suffix
+        # @return [String] cache key
+        def cache_key(suffix = nil)
+          key = "api_#{service_name}_#{session.id}"
+          key += "_#{suffix}" if suffix
+          key
+        end
+
+        # Get service name for logging and caching
+        #
+        # @return [String] service name
+        def service_name
+          self.class.name.demodulize.underscore.gsub("_service", "")
+        end
+
+        # Execute with caching
+        #
+        # @param cache_suffix [String] optional cache suffix
+        # @param expires_in [ActiveSupport::Duration] cache expiration
+        # @yield block to execute if cache miss
+        # @return [Object] cached or fresh result
+        def with_cache(cache_suffix = nil, expires_in: 1.hour)
+          key = cache_key(cache_suffix)
+
+          # Check if caching is enabled
+          if defined?(Rails.cache) && Rails.application.config.action_controller.perform_caching
+            Rails.cache.fetch(key, expires_in: expires_in) do
+              log_service_start("Cache miss, generating fresh data")
+              yield
+            end
+          else
+            log_service_start("Caching disabled, generating fresh data")
+            yield
+          end
+        end
+
+        # Handle service errors consistently
+        #
+        # @param error [StandardError] the error to handle
+        # @return [Hash] error response
+        def handle_error(error)
+          log_error "Error in #{service_name}: #{error.message}", error: error
+          { error: error.message }
+        end
+
+        # Validate session exists
+        #
+        # @return [Hash, nil] error hash if session invalid, nil if valid
+        def validate_session
+          return nil if session
+
+          error_msg = "Session not found"
+          log_error error_msg
+          { error: error_msg }
+        end
+
+        # Previously had pagination parameters method here
+        # Now removed to show all data without pagination
+
+        # Parse filter parameters (override in subclasses)
+        #
+        # @return [Hash] filter parameters
+        def filter_params
+          # Expect params to be a Hash from the controller
+          return {} if params.nil?
+
+          # Extract only the filter-related keys
+          # Make sure we handle the case when params doesn't respond to slice
+          if params.respond_to?(:slice)
+            params.slice(:table, :operation).compact
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/api/changes_data_service.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module Api
+      # Service for handling filtered changes data
+      #
+      # Provides changes data for the sessions changes view and API endpoints
+      # with filtering and caching support.
+      class ChangesDataService < BaseApiService
+        def call
+          start_time = Time.now
+
+          # Check for nil session first
+          return { error: "Session not found" } unless session
+
+          log_service_start("Getting changes data for session #{session.id}")
+
+          validation_error = validate_session
+          return validation_error if validation_error
+
+          begin
+            result = with_cache(cache_suffix) do
+              build_changes_response
+            end
+
+            log_service_completion(start_time, session_id: session.id, filters: filter_params)
+            result
+          rescue StandardError => e
+            handle_error(e)
+          end
+        end
+
+        private
+
+        def build_changes_response
+          {
+            tables_summary: build_filtered_summary,
+            filters: filter_params || {},
+            session_id: session.id,
+            metadata: build_metadata
+          }
+        end
+
+        def build_filtered_summary
+          summary = Storage.sessions.build_tables_summary(session)
+
+          # Handle nil filter_params
+          filter_params_hash = filter_params || {}
+
+          # Apply filters only if they exist
+          summary = filter_by_table(summary, filter_params_hash) if filter_params_hash[:table]
+
+          summary = filter_by_operation(summary, filter_params_hash) if filter_params_hash[:operation]
+
+          summary
+        end
+
+        def filter_by_table(summary, filter_hash)
+          summary.select { |table_name, _| table_name == filter_hash[:table] }
+        end
+
+        def filter_by_operation(summary, filter_hash)
+          operation = filter_hash[:operation].upcase
+
+          summary.each_value do |data|
+            data[:changes] = data[:changes].select do |change|
+              change[:operation] == operation
+            end
+          end
+
+          summary
+        end
+
+        def build_metadata
+          # Make sure filter_params returns a hash even with nil params
+          has_filters = filter_params&.any?
+
+          {
+            generated_at: Time.current,
+            has_filters: has_filters || false,
+            available_tables: available_tables,
+            available_operations: %w[INSERT UPDATE DELETE],
+            total_count: calculate_total_count
+          }
+        end
+
+        def calculate_total_count
+          summary = Storage.sessions.build_tables_summary(session)
+          summary.values.sum { |data| data[:changes]&.length || 0 }
+        end
+
+        def available_tables
+          summary = Storage.sessions.build_tables_summary(session)
+          summary.keys
+        end
+
+        def cache_suffix
+          filter_parts = []
+
+          # Handle nil params safely
+          if params
+            filter_parts << "table_#{params[:table]}" if params[:table]
+            filter_parts << "op_#{params[:operation]}" if params[:operation]
+          end
+
+          filter_parts.any? ? filter_parts.join("_") : nil
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/api/diagram_data_service.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module Api
+      # Service for handling diagram generation and data
+      #
+      # Provides diagram data for the sessions diagrams view and API endpoints
+      # with caching, type validation, and comprehensive error handling.
+      class DiagramDataService < BaseApiService
+        DEFAULT_DIAGRAM_TYPE = "database_tables"
+
+        attr_reader :diagram_type, :diagram_registry
+
+        def initialize(session, diagram_type = nil, params = {})
+          super(session, params)
+          @diagram_registry = Dbwatcher::Services::DiagramTypeRegistry.new
+          @diagram_type = normalize_diagram_type(diagram_type)
+        end
+
+        def call
+          start_time = Time.now
+          log_service_start("Generating #{diagram_type} diagram for session #{session.id}")
+
+          validation_error = validate_session
+          return validation_error if validation_error
+
+          type_validation_error = validate_diagram_type
+          return type_validation_error if type_validation_error
+
+          begin
+            result = with_cache(diagram_type, expires_in: cache_duration) do
+              generate_diagram_data
+            end
+
+            log_service_completion(start_time, session_id: session.id, diagram_type: diagram_type)
+            result
+          rescue StandardError => e
+            handle_error(e)
+          end
+        end
+
+        # Get available diagram types
+        #
+        # @return [Array<String>] available diagram types
+        def self.available_types
+          Dbwatcher::Services::DiagramTypeRegistry.new.available_types
+        end
+
+        # Get available diagram types with metadata
+        #
+        # @return [Hash] available diagram types with metadata
+        def self.available_types_with_metadata
+          Dbwatcher::Services::DiagramTypeRegistry.new.available_types_with_metadata
+        end
+
+        private
+
+        def generate_diagram_data
+          log_service_start("Generating fresh #{diagram_type} diagram")
+
+          result = Storage.sessions.diagram_data(session.id, diagram_type)
+
+          if result[:error]
+            log_error "Diagram generation failed: #{result[:error]}"
+            return result
+          end
+
+          enhance_diagram_result(result)
+        end
+
+        def enhance_diagram_result(base_result)
+          base_result.merge(
+            diagram_type: diagram_type,
+            session_id: session.id,
+            metadata: build_diagram_metadata,
+            cache_info: build_cache_info
+          )
+        end
+
+        def build_diagram_metadata
+          {
+            generated_at: Time.current,
+            diagram_type: diagram_type,
+            available_types: self.class.available_types,
+            cache_duration: cache_duration,
+            supports_refresh: true
+          }
+        end
+
+        def build_cache_info
+          {
+            cache_key: cache_key(diagram_type),
+            expires_in: cache_duration,
+            can_refresh: params[:refresh] != "true"
+          }
+        end
+
+        def normalize_diagram_type(type)
+          normalized = type.to_s.strip.downcase
+          diagram_registry.type_exists?(normalized) ? normalized : DEFAULT_DIAGRAM_TYPE
+        end
+
+        def validate_diagram_type
+          return nil if diagram_registry.type_exists?(diagram_type)
+
+          available_types = diagram_registry.available_types
+          error_msg = "Invalid diagram type '#{diagram_type}'. Valid types: #{available_types.join(", ")}"
+          log_error error_msg
+          { error: error_msg }
+        end
+
+        def cache_duration
+          # Longer cache for complex diagrams based on type
+          case diagram_type
+          when "model_associations"
+            2.hours
+          when "database_tables", "database_tables_inferred"
+            1.hour
+          else
+            30.minutes
+          end
+        end
+
+        # Override cache key to include refresh parameter
+        def cache_key(suffix = nil)
+          key = super
+          key += "_refresh" if params[:refresh] == "true"
+          key
+        end
+
+        # Clear cache if refresh requested
+        def with_cache(cache_suffix = nil, expires_in: 1.hour, &block)
+          if params[:refresh] == "true"
+            key = cache_key(cache_suffix)
+            Rails.cache.delete(key)
+            log_service_start("Cache cleared due to refresh request")
+          end
+
+          super
+        end
+      end
+    end
+  end
+end