dbwatcher 1.0.0 → 1.1.1

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module Api
+      # Service for handling summary statistics data
+      #
+      # Provides enhanced summary data for the sessions summary view and API endpoints
+      # with caching and comprehensive statistics.
+      class SummaryDataService < BaseApiService
+        def call
+          start_time = Time.now
+          log_service_start("Getting summary data for session #{session.id}")
+
+          validation_error = validate_session
+          return validation_error if validation_error
+
+          begin
+            result = with_cache do
+              build_summary_response
+            end
+
+            log_service_completion(start_time, session_id: session.id)
+            result
+          rescue StandardError => e
+            handle_error(e)
+          end
+        end
+
+        private
+
+        def build_summary_response
+          summary_data = base_summary
+
+          return summary_data if summary_data[:error]
+
+          enhance_summary_data(summary_data)
+        end
+
+        def base_summary
+          result = Storage.sessions.summary(session.id)
+
+          if result[:error]
+            log_error "Base summary error: #{result[:error]}"
+            return { error: result[:error] }
+          end
+
+          result
+        end
+
+        def enhance_summary_data(base_summary)
+          tables_summary = Storage.sessions.build_tables_summary(session)
+
+          base_summary.merge(
+            session_id: session.id,
+            enhanced_stats: build_enhanced_stats(tables_summary),
+            tables_breakdown: build_tables_breakdown(tables_summary),
+            metadata: build_metadata,
+            timing: build_timing_info
+          )
+        end
+
+        def build_enhanced_stats(tables_summary)
+          {
+            tables_count: tables_summary.keys.length,
+            total_changes: calculate_total_changes(tables_summary),
+            operations_breakdown: calculate_operations_breakdown(tables_summary),
+            tables_with_changes: tables_summary.keys,
+            most_active_table: find_most_active_table(tables_summary),
+            change_distribution: calculate_change_distribution(tables_summary)
+          }
+        end
+
+        def build_tables_breakdown(tables_summary)
+          tables_data = tables_summary.map do |table_name, data|
+            {
+              table_name: table_name,
+              change_count: data[:changes]&.length || 0,
+              operations: data[:operations] || {},
+              sample_columns: data[:sample_record]&.keys || []
+            }
+          end
+          tables_data.sort_by { |table| -table[:change_count] }
+        end
+
+        def build_metadata
+          {
+            generated_at: Time.current,
+            cache_key: cache_key,
+            data_freshness: "cached"
+          }
+        end
+
+        def calculate_total_changes(tables_summary)
+          tables_summary.values.sum { |data| data[:changes]&.length || 0 }
+        end
+
+        def calculate_operations_breakdown(tables_summary)
+          operations = { "INSERT" => 0, "UPDATE" => 0, "DELETE" => 0 }
+
+          tables_summary.each_value do |data|
+            data[:operations]&.each do |op, count|
+              normalized_op = op.to_s.upcase
+              operations[normalized_op] += count if operations.key?(normalized_op)
+            end
+          end
+
+          operations
+        end
+
+        def find_most_active_table(tables_summary)
+          return nil if tables_summary.empty?
+
+          most_active = tables_summary.max_by do |_, data|
+            data[:changes]&.length || 0
+          end
+
+          {
+            table_name: most_active[0],
+            change_count: most_active[1][:changes]&.length || 0
+          }
+        end
+
+        def calculate_change_distribution(tables_summary)
+          total_changes = calculate_total_changes(tables_summary)
+          return {} if total_changes.zero?
+
+          distribution = {}
+          tables_summary.each do |table_name, data|
+            change_count = data[:changes]&.length || 0
+            percentage = (change_count.to_f / total_changes * 100).round(2)
+            distribution[table_name] = {
+              count: change_count,
+              percentage: percentage
+            }
+          end
+
+          distribution
+        end
+
+        def build_timing_info
+          {
+            started_at: session.started_at,
+            ended_at: session.ended_at,
+            duration: calculate_duration
+          }
+        end
+
+        def calculate_duration
+          return nil unless session.started_at
+
+          end_time = session.ended_at || Time.current
+          ((end_time.to_time - session.started_at.to_time) * 1000).round
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/base_service.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    # Base class for all service objects
+    #
+    # Provides common functionality and patterns for service objects
+    # including logging and consistent call interface.
+    #
+    # @example
+    #   class MyService < BaseService
+    #     def call
+    #       log_info "Starting service"
+    #       # service logic
+    #     end
+    #   end
+    #
+    #   result = MyService.call
+    class BaseService
+      include Dbwatcher::Logging
+
+      # Class method to create instance and call
+      #
+      # @param args [Array] arguments to pass to initialize
+      # @return [Object] result of call method
+      def self.call(*args)
+        new(*args).call
+      end
+
+      # Initialize service
+      #
+      # @param args [Array] service arguments
+      def initialize(*args)
+        # Override in subclasses
+      end
+
+      # Perform service operation
+      #
+      # @return [Object] service result
+      def call
+        raise NotImplementedError, "#{self.class} must implement #call"
+      end
+
+      private
+
+      # Log service start with context
+      #
+      # @param message [String] log message
+      # @param context [Hash] additional context
+      def log_service_start(message, context = {})
+        log_info "#{self.class.name}: #{message}", context
+      end
+
+      # Log service completion with duration
+      #
+      # @param start_time [Time] service start time
+      # @param context [Hash] additional context
+      def log_service_completion(start_time, context = {})
+        duration = Time.now - start_time
+        log_info "#{self.class.name}: Completed in #{duration.round(3)}s", context.merge(duration: duration)
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_analyzers/base_analyzer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "../diagram_data/relationship_params"
+
+module Dbwatcher
+  module Services
+    module DiagramAnalyzers
+      # Abstract base class for diagram analyzers
+      #
+      # This class provides a standard interface that all diagram analyzers must implement
+      # to ensure consistent data flow and transformation to Dataset format.
+      #
+      # @example
+      #   class CustomAnalyzer < BaseAnalyzer
+      #     def analyze(context)
+      #       # Perform analysis and return raw data
+      #     end
+      #
+      #     def transform_to_dataset(raw_data)
+      #       # Transform raw data to Dataset
+      #     end
+      #
+      #     def analyzer_type
+      #       "custom"
+      #     end
+      #   end
+      class BaseAnalyzer < BaseService
+        # Standard interface that all analyzers must implement
+        #
+        # @param context [Hash] analysis context (session, options, etc.)
+        # @return [Object] raw analysis data in analyzer-specific format
+        # @raise [NotImplementedError] if not implemented by subclass
+        def analyze(context)
+          raise NotImplementedError, "Subclasses must implement analyze method"
+        end
+
+        # Transform raw data to standard Dataset
+        #
+        # @param raw_data [Object] raw data from analyze method
+        # @return [DiagramData::Dataset] standardized dataset
+        # @raise [NotImplementedError] if not implemented by subclass
+        def transform_to_dataset(raw_data)
+          raise NotImplementedError, "Subclasses must implement transform_to_dataset"
+        end
+
+        # Get analyzer type classification
+        #
+        # @return [String] analyzer type identifier
+        # @raise [NotImplementedError] if not implemented by subclass
+        def analyzer_type
+          raise NotImplementedError, "Subclasses must implement analyzer_type"
+        end
+
+        # Main entry point - analyze and transform
+        #
+        # @return [DiagramData::Dataset] standardized dataset
+        def call
+          log_service_start "Starting #{self.class.name}", analysis_context
+          start_time = Time.current
+
+          begin
+            # Perform analysis
+            raw_data = analyze(analysis_context)
+
+            # Transform to standard format
+            dataset = transform_to_dataset(raw_data)
+
+            # Validate result
+            unless dataset.is_a?(Dbwatcher::Services::DiagramData::Dataset)
+              raise StandardError, "transform_to_dataset must return a Dataset instance"
+            end
+
+            unless dataset.valid?
+              Rails.logger.warn "#{self.class.name}: Generated invalid dataset: #{dataset.validation_errors.join(", ")}"
+            end
+
+            log_service_completion(start_time, {
+                                     entities_count: dataset.entities.size,
+                                     relationships_count: dataset.relationships.size,
+                                     dataset_valid: dataset.valid?
+                                   })
+
+            dataset
+          rescue StandardError => e
+            Rails.logger.error "#{self.class.name} error: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+            # Return empty dataset instead of failing
+            create_empty_dataset
+          end
+        end
+
+        protected
+
+        # Build analysis context for this analyzer
+        #
+        # @return [Hash] analysis context
+        def analysis_context
+          # Override in subclasses to provide specific context
+          {}
+        end
+
+        # Create empty dataset with metadata
+        #
+        # @return [DiagramData::Dataset] empty dataset
+        def create_empty_dataset
+          Dbwatcher::Services::DiagramData::Dataset.new(
+            metadata: {
+              analyzer: self.class.name,
+              analyzer_type: analyzer_type,
+              empty_reason: "No data found or analysis failed",
+              generated_at: Time.current.iso8601
+            }
+          )
+        end
+
+        # Helper method to create entities
+        #
+        # @param id [String] entity ID
+        # @param name [String] entity name
+        # @param type [String] entity type
+        # @param attributes [Array<Attribute>] entity attributes/properties
+        # @param metadata [Hash] entity metadata
+        # @return [DiagramData::Entity] new entity
+        def create_entity(id:, name:, type: "default", attributes: [], metadata: {})
+          Dbwatcher::Services::DiagramData::Entity.new(
+            id: id,
+            name: name,
+            type: type,
+            attributes: attributes,
+            metadata: metadata
+          )
+        end
+
+        # Helper method to create relationships
+        #
+        # @param params [Hash] relationship parameters
+        # @return [DiagramData::Relationship] new relationship
+        def create_relationship(params)
+          params_obj = Dbwatcher::Services::DiagramData::RelationshipParams.new(params)
+          Dbwatcher::Services::DiagramData::Relationship.new(params_obj)
+        end
+
+        # Helper method to create attributes
+        #
+        # @param name [String] attribute name
+        # @param type [String] attribute data type
+        # @param nullable [Boolean] whether attribute can be null
+        # @param default [Object] default value
+        # @param metadata [Hash] additional type-specific information
+        # @return [DiagramData::Attribute] new attribute
+        def create_attribute(name:, type: nil, nullable: true, default: nil, metadata: {})
+          Dbwatcher::Services::DiagramData::Attribute.new(
+            name: name,
+            type: type,
+            nullable: nullable,
+            default: default,
+            metadata: metadata
+          )
+        end
+      end
+    end
+  end
+end