dbwatcher 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc4ee903407a594933016fc81eab8e7ea90b7f63fe6b046305191b18e87afc27
-  data.tar.gz: e1e9c3f66d04da6e5e043feddf01fb19e02680f0556799e06c5a74ef44da0143
+  metadata.gz: 4b14e37821dd10efdc21bfa6e9a68ff8ffea9096d616616893944aca66dd1c58
+  data.tar.gz: 983a92a4065533bdb7f15a0adeeefc3fd0a97109cf5b08a9c4adaef11bd829f9
 SHA512:
-  metadata.gz: 66c026987650f546ebe5ca2f0ef513d0828f3ca615d28dfeb55174c36c33db4dd1361cea07812905f43d70eab4a369f9ddf0c483191b3337b22f89c699412b19
-  data.tar.gz: 95d9a01e5dd54e81d9a1f6260720fb43d2ef650a3c550012cb943d39c66e4d13616d796a39b489bdffdc9816f30d6bedbd78ad3c0537c588ba120821964c3e19
+  metadata.gz: 86071979a9e26aa6e0e5f289b4079804615e4477357dc894305d8eab047c328c9a1d97651e37889c913f073fc8f156abd410582adbe8581f68443f3d195fc5f4
+  data.tar.gz: '09bacda0cc050854b53d8567b46c791cfc440825598bb3c06300e2f4f572dd1f3cde1df0b127a332edd9a3995077ef7beae9bafc47cb7629478d2671a0d2691a'

data/app/controllers/dbwatcher/api/v1/sessions_controller.rb

@@ -8,32 +8,23 @@ module Dbwatcher
 
         def tables_data
           Rails.logger.info "API::V1::SessionsController#tables_data: Getting tables for session #{@session.id}"
-
-          # Paginated, filtered tables data
-          # Convert ActionController::Parameters to a hash before passing to service
-          service = Dbwatcher::Services::Api::TablesDataService.new(@session, filter_params.to_h)
+          service = Dbwatcher::Services::Api::TablesDataService.new(@session, tables_data_params)
           render json: service.call
         end
 
         def summary_data
           Rails.logger.info "API::V1::SessionsController#summary_data: Getting summary for session #{@session.id}"
-
-          # Aggregated summary statistics
           service = Dbwatcher::Services::Api::SummaryDataService.new(@session)
           render json: service.call
         end
 
         def diagram_data
           Rails.logger.info "API::V1::SessionsController#diagram_data: Getting diagram for session #{@session.id}"
-
-          # Generated diagram content with caching
-          # Convert ActionController::Parameters to a hash before passing to service
-          diagram_params = params.to_unsafe_h
           service = Dbwatcher::Services::Api::DiagramDataService.new(@session, params[:type], diagram_params)
           result = service.call
 
           if result[:error]
-            render json: { error: result[:error] }, status: :unprocessable_entity
+            render_error(result[:error])
           else
             render json: result
           end
@@ -41,13 +32,11 @@ module Dbwatcher
 
         def timeline_data
           Rails.logger.info "API::V1::SessionsController#timeline_data: Getting timeline for session #{@session.id}"
-
-          # Timeline data processed from session changes
           service = Dbwatcher::Services::TimelineDataService.new(@session)
           result = service.call
 
           if result[:errors].any?
-            render json: { error: result[:errors].first[:message] }, status: :unprocessable_entity
+            render_error(result[:errors].first[:message])
           else
             render json: result
           end
@@ -55,7 +44,6 @@ module Dbwatcher
 
         def diagram_types
           Rails.logger.info "API::V1::SessionsController#diagram_types: Getting available diagram types"
-
           render json: {
             types: Dbwatcher::Services::Api::DiagramDataService.available_types_with_metadata,
             default_type: "database_tables"
@@ -66,11 +54,19 @@ module Dbwatcher
 
         def find_session
           @session = Storage.sessions.find(params[:id])
-          render json: { error: "Session not found" }, status: :not_found unless @session
+          render_error("Session not found", :not_found) unless @session
+        end
+
+        def tables_data_params
+          params.permit(:id, :table, :operation, :page, :per_page, session: {}).to_h
+        end
+
+        def diagram_params
+          params.permit(:type, :format, :include_columns, :show_relationships, session: {}).to_h
         end
 
-        def filter_params
-          params.permit(:table, :operation, :page, :per_page)
+        def render_error(message, status = :unprocessable_entity)
+          render json: { error: message }, status: status
         end
       end
     end

data/lib/dbwatcher/configuration.rb

@@ -26,6 +26,9 @@ module Dbwatcher
                   :collect_sensitive_env_vars, :system_info_cache_duration,
                   :system_info_include_performance_metrics
 
+    # Logging configuration
+    attr_accessor :debug_logging
+
     # Initialize with default values
     def initialize
       # Storage configuration defaults
@@ -47,6 +50,9 @@ module Dbwatcher
 
       # Initialize system information configuration with defaults
       initialize_system_info_config
+
+      # Initialize logging configuration with defaults
+      initialize_logging_config
     end
 
     # Initialize diagram configuration with default values
@@ -73,6 +79,11 @@ module Dbwatcher
       @system_info_include_performance_metrics = true
     end
 
+    # Initialize logging configuration with default values
+    def initialize_logging_config
+      @debug_logging = false
+    end
+
     # Validate configuration
     #
     # @return [Boolean] true if configuration is valid

data/lib/dbwatcher/logging.rb

@@ -14,9 +14,12 @@ module Dbwatcher
     end
 
     # Log a debug message with optional context
+    # Only logs if debug mode is enabled
     # @param message [String] the log message
     # @param context [Hash] additional context data
     def log_debug(message, context = {})
+      return unless debug_enabled?
+
       log_with_level(:debug, message, context)
     end
 
@@ -34,6 +37,16 @@ module Dbwatcher
       log_with_level(:error, message, context)
     end
 
+    # Check if debug logging is enabled
+    # @return [Boolean] true if debug logging is enabled
+    def debug_enabled?
+      return Dbwatcher.configuration.debug_logging if defined?(Dbwatcher.configuration) &&
+                                                      Dbwatcher.configuration.respond_to?(:debug_logging)
+      return Rails.env.development? if defined?(Rails)
+
+      false
+    end
+
     private
 
     def log_with_level(level, message, context)
@@ -51,7 +64,16 @@ module Dbwatcher
     end
 
     def component_name
-      self.class.name.split("::").last
+      if is_a?(Module) && !is_a?(Class)
+        # For modules
+        name.to_s.split("::").last
+      elsif self.class.name
+        # For classes
+        self.class.name.split("::").last
+      else
+        # Fallback
+        "Logger"
+      end
     end
 
     def rails_logger

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

@@ -232,6 +232,37 @@ module Dbwatcher
         # @param primary_key [String, nil] optional primary key for testing
         # @return [Boolean] true if likely self-referential
         def self_referential_column?(column_name, table_name, primary_key = nil)
+          # Get the singular form of the table name
+          base_name = singularize(table_name)
+
+          # Special case for post_id in posts table - not a self-reference
+          return false if column_name == "#{base_name}_id" && table_name == "posts" && base_name == "post"
+
+          # Check primary key if this is a table-specific reference
+          if column_name == "#{base_name}_id"
+            if primary_key.nil?
+              begin
+                primary_key = connection.primary_key(table_name)
+              rescue StandardError
+                return false
+              end
+            end
+
+            return column_name != primary_key
+          end
+
+          # Use pattern matching to check various self-referential patterns
+          common_pattern?(column_name) ||
+            hierarchy_pattern?(column_name, base_name) ||
+            relationship_pattern?(column_name) ||
+            directional_pattern?(column_name)
+        end
+
+        # Check if column matches common self-referential patterns
+        #
+        # @param column_name [String] column name to check
+        # @return [Boolean] true if matches common patterns
+        def common_pattern?(column_name)
           # Common self-referential patterns
           self_ref_patterns = %w[
             parent_id
@@ -257,52 +288,47 @@ module Dbwatcher
             replied_to_id
           ]
 
-          # Check for exact matches with common patterns
-          return true if self_ref_patterns.include?(column_name)
-
-          # Get the singular form of the table name
-          base_name = singularize(table_name)
-
-          # Special case for post_id in posts table - not a self-reference
-          return false if column_name == "#{base_name}_id" && table_name == "posts" && base_name == "post"
-
-          # Check for table-specific self-references (e.g., comment_id in comments table)
-          if column_name == "#{base_name}_id"
-            # Check if this is not the primary key column
-            if primary_key.nil?
-              begin
-                primary_key = connection.primary_key(table_name)
-              rescue StandardError
-                return false
-              end
-            end
-
-            return column_name != primary_key
-          end
+          self_ref_patterns.include?(column_name)
+        end
 
-          # Check for hierarchy patterns with table name
+        # Check for hierarchy patterns with table name
+        #
+        # @param column_name [String] column name to check
+        # @param base_name [String] singular form of table name
+        # @return [Boolean] true if matches hierarchy patterns
+        def hierarchy_pattern?(column_name, base_name)
           hierarchy_prefixes = %w[parent child ancestor descendant superior subordinate manager supervisor]
-          hierarchy_prefixes.each do |prefix|
-            # Check for patterns like parent_comment_id in comments table
-            return true if column_name.start_with?("#{prefix}_#{base_name}_id")
 
-            # Check for patterns like parent_of_id in any table
-            return true if column_name.start_with?("#{prefix}_of_id")
+          hierarchy_prefixes.any? do |prefix|
+            # Check for patterns like parent_comment_id in comments table
+            column_name.start_with?("#{prefix}_#{base_name}_id") ||
+              # Check for patterns like parent_of_id in any table
+              column_name.start_with?("#{prefix}_of_id")
           end
+        end
 
-          # Check for relationship patterns
+        # Check for relationship patterns
+        #
+        # @param column_name [String] column name to check
+        # @return [Boolean] true if matches relationship patterns
+        def relationship_pattern?(column_name)
           relationship_patterns = %w[related linked connected associated referenced]
-          relationship_patterns.each do |pattern|
-            return true if column_name.start_with?("#{pattern}_")
+
+          relationship_patterns.any? do |pattern|
+            column_name.start_with?("#{pattern}_")
           end
+        end
 
-          # Check for directional patterns
+        # Check for directional patterns
+        #
+        # @param column_name [String] column name to check
+        # @return [Boolean] true if matches directional patterns
+        def directional_pattern?(column_name)
           directional_patterns = %w[previous next original copy source target]
-          directional_patterns.each do |pattern|
-            return true if column_name.start_with?("#{pattern}_")
-          end
 
-          false
+          directional_patterns.any? do |pattern|
+            column_name.start_with?("#{pattern}_")
+          end
         end
 
         # Analyze junction tables (many-to-many relationships)

data/lib/dbwatcher/services/diagram_generator.rb

@@ -5,81 +5,58 @@ require_relative "diagram_type_registry"
 
 module Dbwatcher
   module Services
-    # Orchestrator for diagram generation using strategy pattern
+    # Service for generating diagrams from session data
     #
-    # This service coordinates diagram generation by delegating to appropriate
-    # analyzer and strategy classes with clean error handling.
+    # Coordinates the process of generating diagrams by:
+    # 1. Loading session data
+    # 2. Using appropriate analyzers to extract relationships
+    # 3. Applying diagram generation strategies
     #
     # @example
-    #   generator = DiagramGenerator.new(session_id, 'database_tables')
+    #   generator = DiagramGenerator.new(session_id: "abc123", diagram_type: "database_tables")
     #   result = generator.call
-    #   # => { content: "erDiagram\n    USERS ||--o{ ORDERS : user_id", type: 'erDiagram' }
-    class DiagramGenerator < BaseService
-      attr_reader :session_id, :diagram_type, :registry, :error_handler, :logger
+    #   # => { success: true, content: "erDiagram\n...", type: "erDiagram" }
+    class DiagramGenerator
+      include Dbwatcher::Logging
 
-      # Initialize with session id and diagram type
+      # Initialize generator with options
       #
-      # @param session_id [String] session identifier
+      # @param session_id [String] session ID to analyze
       # @param diagram_type [String] type of diagram to generate
-      # @param dependencies [Hash] optional dependency injection
-      # @option dependencies [DiagramTypeRegistry] :registry type registry
-      # @option dependencies [DiagramErrorHandler] :error_handler error handler
-      # @option dependencies [Logger] :logger logger instance
-      def initialize(session_id, diagram_type = "database_tables", dependencies = {})
+      # @param options [Hash] additional options
+      def initialize(session_id:, diagram_type:, options: {})
         @session_id = session_id
         @diagram_type = diagram_type
-        @registry = dependencies[:registry] || DiagramTypeRegistry.new
-        @error_handler = dependencies[:error_handler] || DiagramErrorHandler.new
-        @logger = dependencies[:logger] || default_logger
-        super()
+        @options = options
+        @registry = options[:registry] || DiagramTypeRegistry.new
+        @logger = options[:logger] || Rails.logger
       end
 
-      # Generate diagram for session
+      # Generate diagram
       #
-      # @return [Hash] diagram data with content and type
+      # @return [Hash] diagram generation result
       def call
-        @logger.info("Generating diagram for session #{@session_id} with type #{@diagram_type}")
-        start_time = Time.now
+        log_info("Generating diagram of type #{@diagram_type} for session #{@session_id}")
 
-        begin
-          result = generate_diagram
-          log_completion(start_time, result)
-          result
-        rescue StandardError => e
-          @error_handler.handle_generation_error(e, error_context)
-        end
-      end
+        start_time = Time.now
+        result = generate_diagram
 
-      # Get available diagram types with metadata
-      #
-      # @return [Hash] diagram types with metadata
-      def available_types
-        @registry.available_types_with_metadata
-      end
+        duration_ms = ((Time.now - start_time) * 1000).round(2)
+        log_info("Diagram generation completed in #{duration_ms}ms", {
+                   session_id: @session_id,
+                   diagram_type: @diagram_type,
+                   success: result[:success]
+                 })
 
-      # Get available diagram types (class method for backward compatibility)
-      #
-      # @return [Hash] diagram types with metadata
-      def self.available_types
-        DiagramTypeRegistry.new.available_types_with_metadata
+        result
+      rescue StandardError => e
+        log_error("Diagram generation failed: #{e.message}", error_context)
+        error_result("Diagram generation failed: #{e.message}")
       end
 
       private
 
-      # Default logger when no logger is provided
-      #
-      # @return [Logger] default logger instance
-      def default_logger
-        # Use Rails logger if available, otherwise create a simple logger
-        if defined?(Rails) && Rails.respond_to?(:logger)
-          Rails.logger
-        else
-          require "logger"
-          Logger.new($stdout)
-        end
-      end
-
-      # Generate diagram using standardized analyzer-to-strategy flow
+      # Generate diagram based on configuration
       #
       # @return [Hash] diagram generation result
       def generate_diagram
@@ -96,8 +73,8 @@ module Dbwatcher
         analyzer = @registry.create_analyzer(@diagram_type, session)
         dataset = analyzer.call
 
-        @logger.debug("Generated dataset with #{dataset.entities.size} entities and " \
-                      "#{dataset.relationships.size} relationships")
+        log_debug("Generated dataset with #{dataset.entities.size} entities and " \
+                  "#{dataset.relationships.size} relationships")
 
         # Create strategy and generate diagram from dataset
         strategy = @registry.create_strategy(@diagram_type)
@@ -110,7 +87,7 @@ module Dbwatcher
       def load_session
         Dbwatcher::Storage.sessions.find(@session_id)
       rescue StandardError => e
-        @logger.warn("Could not load session #{@session_id}: #{e.message}")
+        log_warn("Could not load session #{@session_id}: #{e.message}")
         nil
       end
 
@@ -138,17 +115,6 @@ module Dbwatcher
           generated_at: Time.now.iso8601
         }
       end
-
-      # Log generation completion
-      #
-      # @param start_time [Time] operation start time
-      # @param result [Hash] generation result
-      def log_completion(start_time, result)
-        duration = Time.now - start_time
-        success = result[:success] || false
-        @logger.info("Diagram generation completed for session #{@session_id} type #{@diagram_type} " \
-                     "in #{(duration * 1000).round(2)}ms - Success: #{success}")
-      end
     end
   end
 end

data/lib/dbwatcher/services/diagram_strategies/base_diagram_strategy.rb

@@ -8,6 +8,8 @@ module Dbwatcher
       # Defines the common interface and shared behavior for all diagram generation
       # strategies. Subclasses must implement the render_diagram method.
       class BaseDiagramStrategy
+        include Dbwatcher::Logging
+
         attr_reader :syntax_builder, :logger
 
         # Initialize strategy with dependencies
@@ -25,8 +27,8 @@ module Dbwatcher
         # @param dataset [Dataset] standardized dataset
         # @return [Hash] diagram generation result
         def generate_from_dataset(dataset)
-          @logger.info("Generating diagram from dataset with #{dataset.entities.size} entities and " \
-                       "#{dataset.relationships.size} relationships")
+          log_info("Generating diagram from dataset with #{dataset.entities.size} entities and " \
+                   "#{dataset.relationships.size} relationships")
           start_time = Time.current
 
           begin
@@ -40,7 +42,7 @@ module Dbwatcher
 
             result
           rescue StandardError => e
-            @logger.error("Diagram generation failed: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+            log_error("Diagram generation failed: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
             error_response("Diagram generation failed: #{e.message}")
           end
         end
@@ -59,13 +61,25 @@ module Dbwatcher
 
         protected
 
-        # Render diagram from dataset (abstract method)
+        # Render diagram from dataset (template method)
         #
         # @param dataset [Dataset] standardized dataset
         # @return [Hash] diagram generation result
-        # @raise [NotImplementedError] if not implemented by subclass
         def render_diagram(dataset)
-          raise NotImplementedError, "Subclasses must implement render_diagram method"
+          log_debug("Rendering #{mermaid_diagram_type} diagram from dataset with " \
+                    "#{dataset.entities.size} entities and #{dataset.relationships.size} relationships")
+
+          # Generate diagram content directly from dataset
+          content = generate_diagram_content(dataset)
+          success_response(content, mermaid_diagram_type)
+        end
+
+        # Generate diagram content based on dataset (to be implemented by subclasses)
+        #
+        # @param dataset [Dataset] standardized dataset
+        # @return [String] diagram content
+        def generate_diagram_content(dataset)
+          raise NotImplementedError, "Subclasses must implement generate_diagram_content method"
         end
 
         # Build empty diagram with message
@@ -118,9 +132,9 @@ module Dbwatcher
         # @param operation [String] operation name
         # @param duration [Float] operation duration in seconds
         # @param context [Hash] additional context
-        def log_operation_completion(operation, duration, _context = {})
-          @logger.info("Strategy operation completed: #{operation} by #{self.class.name} " \
-                       "in #{(duration * 1000).round(2)}ms")
+        def log_operation_completion(operation, duration, context = {})
+          log_info("Strategy operation completed: #{operation} by #{self.class.name} " \
+                   "in #{(duration * 1000).round(2)}ms", context)
         end
 
         # Create default syntax builder

data/lib/dbwatcher/services/diagram_strategies/class_diagram_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "standard_diagram_strategy"
+
 module Dbwatcher
   module Services
     module DiagramStrategies
@@ -7,31 +9,10 @@ module Dbwatcher
       #
       # Handles class diagram generation by converting dataset entities and relationships
       # to Mermaid class diagram syntax.
-      class ClassDiagramStrategy < BaseDiagramStrategy
-        protected
-
-        # Render class diagram from standardized dataset
-        #
-        # @param dataset [Dataset] standardized dataset
-        # @return [Hash] diagram generation result
-        def render_diagram(dataset)
-          @logger.debug "Rendering class diagram from dataset with #{dataset.entities.size} entities and " \
-                        "#{dataset.relationships.size} relationships"
-
-          # Generate diagram content directly from dataset
-          content = if dataset.relationships.empty? && dataset.entities.empty?
-                      @syntax_builder.build_empty_class_diagram("No model associations or entities found")
-                    else
-                      @syntax_builder.build_class_diagram_from_dataset(dataset)
-                    end
-
-          success_response(content, "classDiagram")
-        end
-
+      class ClassDiagramStrategy < StandardDiagramStrategy
         private
 
         # Strategy metadata methods
-
         def strategy_name
           "Model Associations (Class Diagram)"
         end
@@ -43,6 +24,19 @@ module Dbwatcher
         def mermaid_diagram_type
           "classDiagram"
         end
+
+        # Diagram generation configuration
+        def empty_diagram_method
+          :build_empty_class_diagram
+        end
+
+        def empty_diagram_message
+          "No model associations or entities found"
+        end
+
+        def full_diagram_method
+          :build_class_diagram_from_dataset
+        end
       end
     end
   end

data/lib/dbwatcher/services/diagram_strategies/diagram_strategy_helpers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramStrategies
+      # Helper module for diagram strategies
+      #
+      # Provides common utility methods for diagram strategies to reduce code duplication.
+      # These methods handle common patterns in diagram generation.
+      module DiagramStrategyHelpers
+        # Generate diagram content with empty state handling
+        #
+        # @param dataset [Dataset] standardized dataset
+        # @param options [Hash] options for diagram generation
+        # @option options [Symbol] :empty_method method to call for empty diagram
+        # @option options [String] :empty_message message for empty diagram
+        # @option options [Symbol] :empty_entities_method method to call for diagram with only entities
+        # @option options [Symbol] :full_diagram_method method to call for complete diagram
+        # @return [String] diagram content
+        def generate_standard_diagram_content(dataset, options)
+          if dataset.relationships.empty? && dataset.entities.empty?
+            @syntax_builder.send(options[:empty_method], options[:empty_message])
+          elsif dataset.relationships.empty? && options[:empty_entities_method]
+            # Show isolated entities if no relationships but entities exist
+            @syntax_builder.send(options[:empty_entities_method], dataset.entities.values)
+          else
+            @syntax_builder.send(options[:full_diagram_method], dataset)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_strategies/erd_diagram_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "standard_diagram_strategy"
+
 module Dbwatcher
   module Services
     module DiagramStrategies
@@ -7,34 +9,10 @@ module Dbwatcher
       #
       # Handles ERD diagram generation by converting dataset entities and relationships
       # to Mermaid ERD syntax.
-      class ErdDiagramStrategy < BaseDiagramStrategy
-        protected
-
-        # Render ERD diagram from standardized dataset
-        #
-        # @param dataset [Dataset] standardized dataset
-        # @return [Hash] diagram generation result
-        def render_diagram(dataset)
-          @logger.debug "Rendering ERD diagram from dataset with #{dataset.entities.size} entities and " \
-                        "#{dataset.relationships.size} relationships"
-
-          # Generate diagram content directly from dataset
-          content = if dataset.relationships.empty? && dataset.entities.empty?
-                      @syntax_builder.build_empty_erd("No database relationships or tables found")
-                    elsif dataset.relationships.empty?
-                      # Show isolated tables if no relationships but entities exist
-                      @syntax_builder.build_erd_diagram_with_tables(dataset.entities.values)
-                    else
-                      @syntax_builder.build_erd_diagram_from_dataset(dataset)
-                    end
-
-          success_response(content, "erDiagram")
-        end
-
+      class ErdDiagramStrategy < StandardDiagramStrategy
         private
 
         # Strategy metadata methods
-
         def strategy_name
           "Database Schema (ERD)"
         end
@@ -46,6 +24,23 @@ module Dbwatcher
         def mermaid_diagram_type
           "erDiagram"
         end
+
+        # Diagram generation configuration
+        def empty_diagram_method
+          :build_empty_erd
+        end
+
+        def empty_diagram_message
+          "No database relationships or tables found"
+        end
+
+        def empty_entities_method
+          :build_erd_diagram_with_tables
+        end
+
+        def full_diagram_method
+          :build_erd_diagram_from_dataset
+        end
       end
     end
   end

data/lib/dbwatcher/services/diagram_strategies/flowchart_diagram_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "standard_diagram_strategy"
+
 module Dbwatcher
   module Services
     module DiagramStrategies
@@ -7,34 +9,10 @@ module Dbwatcher
       #
       # Handles flowchart diagram generation by converting dataset entities and relationships
       # to Mermaid flowchart syntax.
-      class FlowchartDiagramStrategy < BaseDiagramStrategy
-        protected
-
-        # Render flowchart diagram from standardized dataset
-        #
-        # @param dataset [Dataset] standardized dataset
-        # @return [Hash] diagram generation result
-        def render_diagram(dataset)
-          @logger.debug "Rendering flowchart diagram from dataset with #{dataset.entities.size} entities and " \
-                        "#{dataset.relationships.size} relationships"
-
-          # Generate diagram content directly from dataset
-          content = if dataset.relationships.empty? && dataset.entities.empty?
-                      @syntax_builder.build_empty_flowchart("No model associations or entities found")
-                    elsif dataset.relationships.empty?
-                      # Show isolated nodes if no relationships but entities exist
-                      @syntax_builder.build_flowchart_with_nodes(dataset.entities.values)
-                    else
-                      @syntax_builder.build_flowchart_diagram_from_dataset(dataset)
-                    end
-
-          success_response(content, "flowchart")
-        end
-
+      class FlowchartDiagramStrategy < StandardDiagramStrategy
         private
 
         # Strategy metadata methods
-
         def strategy_name
           "Model Associations"
         end
@@ -46,6 +24,23 @@ module Dbwatcher
         def mermaid_diagram_type
           "flowchart"
         end
+
+        # Diagram generation configuration
+        def empty_diagram_method
+          :build_empty_flowchart
+        end
+
+        def empty_diagram_message
+          "No model associations or entities found"
+        end
+
+        def empty_entities_method
+          :build_flowchart_with_nodes
+        end
+
+        def full_diagram_method
+          :build_flowchart_diagram_from_dataset
+        end
       end
     end
   end

data/lib/dbwatcher/services/diagram_strategies/standard_diagram_strategy.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "base_diagram_strategy"
+require_relative "diagram_strategy_helpers"
+
+module Dbwatcher
+  module Services
+    module DiagramStrategies
+      # Standard diagram strategy implementation
+      #
+      # Provides a common implementation for diagram strategies that follow
+      # the standard pattern of generating diagrams from datasets.
+      # Specific strategies can inherit from this class and provide only
+      # the necessary configuration.
+      class StandardDiagramStrategy < BaseDiagramStrategy
+        include DiagramStrategyHelpers
+
+        # Initialize with configuration options
+        #
+        # @param dependencies [Hash] injected dependencies
+        # @option dependencies [Object] :syntax_builder Mermaid syntax builder
+        # @option dependencies [Logger] :logger logger instance
+        def initialize(dependencies = {})
+          super
+          @diagram_options = diagram_options
+        end
+
+        protected
+
+        # Generate diagram content from dataset using standard pattern
+        #
+        # @param dataset [Dataset] standardized dataset
+        # @return [String] diagram content
+        def generate_diagram_content(dataset)
+          generate_standard_diagram_content(dataset, @diagram_options)
+        end
+
+        # Get diagram generation options
+        #
+        # @return [Hash] diagram options
+        def diagram_options
+          {
+            empty_method: empty_diagram_method,
+            empty_message: empty_diagram_message,
+            empty_entities_method: empty_entities_method,
+            full_diagram_method: full_diagram_method
+          }
+        end
+
+        # Get method name for generating empty diagram
+        #
+        # @return [Symbol] method name
+        def empty_diagram_method
+          raise NotImplementedError, "Subclasses must implement empty_diagram_method"
+        end
+
+        # Get message for empty diagram
+        #
+        # @return [String] empty diagram message
+        def empty_diagram_message
+          "No data available for diagram"
+        end
+
+        # Get method name for generating diagram with only entities
+        #
+        # @return [Symbol] method name
+        def empty_entities_method
+          nil
+        end
+
+        # Get method name for generating full diagram
+        #
+        # @return [Symbol] method name
+        def full_diagram_method
+          raise NotImplementedError, "Subclasses must implement full_diagram_method"
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_system.rb

@@ -29,6 +29,8 @@ require_relative "diagram_analyzers/model_association_analyzer"
 
 # Diagram strategies
 require_relative "diagram_strategies/base_diagram_strategy"
+require_relative "diagram_strategies/diagram_strategy_helpers"
+require_relative "diagram_strategies/standard_diagram_strategy"
 require_relative "diagram_strategies/erd_diagram_strategy"
 require_relative "diagram_strategies/class_diagram_strategy"
 require_relative "diagram_strategies/flowchart_diagram_strategy"
@@ -41,6 +43,13 @@ module Dbwatcher
     # Diagram System Module
     # Provides centralized access to diagram generation capabilities
     module DiagramSystem
+      extend Dbwatcher::Logging
+
+      # Explicitly set the component name for logging
+      def self.component_name
+        "DiagramSystem"
+      end
+
       # Get available diagram types
       #
       # @return [Array<String>] available diagram type names
@@ -54,7 +63,11 @@ module Dbwatcher
       # @param diagram_type [String] type of diagram to generate
       # @return [Hash] diagram generation result
       def self.generate(session_id, diagram_type = "database_tables")
-        DiagramGenerator.new(session_id, diagram_type).call
+        log_debug("Generating diagram of type #{diagram_type} for session #{session_id}")
+        generator = DiagramGenerator.new(session_id: session_id, diagram_type: diagram_type)
+        result = generator.call
+        log_debug("Diagram generation completed with success=#{result[:success]}")
+        result
       end
 
       # Check if diagram type is supported

data/lib/dbwatcher/services/mermaid_syntax/base_builder.rb

@@ -15,6 +15,8 @@ module Dbwatcher
       #     end
       #   end
       class BaseBuilder
+        include Dbwatcher::Logging
+
         # Initialize a new builder with configuration
         #
         # @param config [Hash] configuration options

data/lib/dbwatcher/services/mermaid_syntax_builder.rb

@@ -15,6 +15,8 @@ module Dbwatcher
     #   content = builder.build_erd_diagram_from_dataset(dataset)
     #   # => "erDiagram\n    USERS ||--o{ ORDERS : user_id"
     class MermaidSyntaxBuilder
+      include Dbwatcher::Logging
+
       # Custom error classes
       class SyntaxValidationError < StandardError; end
       class UnsupportedDiagramTypeError < StandardError; end
@@ -40,8 +42,8 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid ERD syntax
       def build_erd_diagram_from_dataset(dataset, options = {})
-        @logger.debug "Building ERD diagram from dataset with #{dataset.entities.size} entities and " \
-                      "#{dataset.relationships.size} relationships"
+        log_debug("Building ERD diagram from dataset with #{dataset.entities.size} entities and " \
+                  "#{dataset.relationships.size} relationships")
 
         builder = MermaidSyntax::ErdBuilder.new(@config.merge(options))
         builder.build_from_dataset(dataset)
@@ -53,8 +55,8 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid class diagram syntax
       def build_class_diagram_from_dataset(dataset, options = {})
-        @logger.debug "Building class diagram from dataset with #{dataset.entities.size} entities and " \
-                      "#{dataset.relationships.size} relationships"
+        log_debug("Building class diagram from dataset with #{dataset.entities.size} entities and " \
+                  "#{dataset.relationships.size} relationships")
 
         builder = MermaidSyntax::ClassDiagramBuilder.new(@config.merge(options))
         builder.build_from_dataset(dataset)
@@ -66,8 +68,8 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid flowchart syntax
       def build_flowchart_diagram_from_dataset(dataset, options = {})
-        @logger.debug "Building flowchart diagram from dataset with #{dataset.entities.size} entities and " \
-                      "#{dataset.relationships.size} relationships"
+        log_debug("Building flowchart diagram from dataset with #{dataset.entities.size} entities and " \
+                  "#{dataset.relationships.size} relationships")
 
         builder = MermaidSyntax::FlowchartBuilder.new(@config.merge(options))
         builder.build_from_dataset(dataset)
@@ -125,7 +127,7 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid ERD syntax
       def build_erd_diagram_with_tables(entities, options = {})
-        @logger.debug "Building ERD diagram with #{entities.size} isolated tables"
+        log_debug("Building ERD diagram with #{entities.size} isolated tables")
 
         dataset = Dbwatcher::Services::DiagramData::Dataset.new
         entities.each { |entity| dataset.add_entity(entity) }
@@ -139,7 +141,7 @@ module Dbwatcher
       # @param options [Hash] generation options
       # @return [String] Mermaid flowchart syntax
       def build_flowchart_with_nodes(entities, options = {})
-        @logger.debug "Building flowchart diagram with #{entities.size} isolated nodes"
+        log_debug("Building flowchart diagram with #{entities.size} isolated nodes")
 
         dataset = Dbwatcher::Services::DiagramData::Dataset.new
         entities.each { |entity| dataset.add_entity(entity) }

data/lib/dbwatcher/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dbwatcher
-  VERSION = "1.1.3"
+  VERSION = "1.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbwatcher
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Huy Nguyen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-11 00:00:00.000000000 Z
+date: 2025-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -266,8 +266,10 @@ files:
 - lib/dbwatcher/services/diagram_generator.rb
 - lib/dbwatcher/services/diagram_strategies/base_diagram_strategy.rb
 - lib/dbwatcher/services/diagram_strategies/class_diagram_strategy.rb
+- lib/dbwatcher/services/diagram_strategies/diagram_strategy_helpers.rb
 - lib/dbwatcher/services/diagram_strategies/erd_diagram_strategy.rb
 - lib/dbwatcher/services/diagram_strategies/flowchart_diagram_strategy.rb
+- lib/dbwatcher/services/diagram_strategies/standard_diagram_strategy.rb
 - lib/dbwatcher/services/diagram_system.rb
 - lib/dbwatcher/services/diagram_type_registry.rb
 - lib/dbwatcher/services/mermaid_syntax/base_builder.rb