dbwatcher 1.1.2 → 1.1.4

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) }