dbwatcher 1.0.0 → 1.1.1

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramStrategies
+      # Abstract base class for diagram generation strategies
+      #
+      # Defines the common interface and shared behavior for all diagram generation
+      # strategies. Subclasses must implement the render_diagram method.
+      class BaseDiagramStrategy
+        attr_reader :syntax_builder, :logger
+
+        # Initialize strategy with dependencies
+        #
+        # @param dependencies [Hash] injected dependencies
+        # @option dependencies [Object] :syntax_builder Mermaid syntax builder
+        # @option dependencies [Logger] :logger logger instance
+        def initialize(dependencies = {})
+          @syntax_builder = dependencies[:syntax_builder] || create_default_syntax_builder
+          @logger = dependencies[:logger] || Rails.logger || Logger.new($stdout)
+        end
+
+        # Generate diagram from standardized dataset
+        #
+        # @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")
+          start_time = Time.current
+
+          begin
+            # Generate diagram using dataset
+            result = render_diagram(dataset)
+
+            log_operation_completion("diagram generation", Time.current - start_time, {
+                                       entities_count: dataset.entities.size,
+                                       relationships_count: dataset.relationships.size
+                                     })
+
+            result
+          rescue StandardError => e
+            @logger.error("Diagram generation failed: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+            error_response("Diagram generation failed: #{e.message}")
+          end
+        end
+
+        # Get strategy metadata (abstract method)
+        #
+        # @return [Hash] strategy metadata including name, description
+        # @raise [NotImplementedError] if not implemented by subclass
+        def metadata
+          {
+            name: strategy_name,
+            description: strategy_description,
+            mermaid_type: mermaid_diagram_type
+          }
+        end
+
+        protected
+
+        # Render diagram from dataset (abstract 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"
+        end
+
+        # Build empty diagram with message
+        #
+        # @param message [String] message to display in empty diagram
+        # @param diagram_type [String] type of empty diagram to create
+        # @return [Hash] empty diagram result
+        def build_empty_diagram(message, diagram_type = nil)
+          diagram_type ||= mermaid_diagram_type
+          content = @syntax_builder.build_empty_diagram(message, diagram_type)
+          success_response(content, diagram_type)
+        end
+
+        # Create success response
+        #
+        # @param content [String] diagram content
+        # @param type [String] diagram type
+        # @return [Hash] success response
+        def success_response(content, type)
+          {
+            success: true,
+            content: content,
+            type: type,
+            generated_at: Time.current,
+            metadata: {
+              strategy: self.class.name
+            }
+          }
+        end
+
+        # Create error response
+        #
+        # @param message [String] error message
+        # @return [Hash] error response
+        def error_response(message)
+          {
+            success: false,
+            error: message,
+            content: nil,
+            type: nil,
+            generated_at: Time.current,
+            metadata: {
+              strategy: self.class.name
+            }
+          }
+        end
+
+        # Log operation completion
+        #
+        # @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")
+        end
+
+        # Create default syntax builder
+        #
+        # @return [MermaidSyntaxBuilder] syntax builder instance
+        def create_default_syntax_builder
+          Dbwatcher::Services::MermaidSyntaxBuilder.new
+        end
+
+        # Strategy metadata methods (abstract)
+
+        def strategy_name
+          raise NotImplementedError, "Subclasses must implement strategy_name"
+        end
+
+        def strategy_description
+          raise NotImplementedError, "Subclasses must implement strategy_description"
+        end
+
+        def mermaid_diagram_type
+          raise NotImplementedError, "Subclasses must implement mermaid_diagram_type"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramStrategies
+      # Strategy for generating class diagrams from model associations
+      #
+      # 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
+
+        private
+
+        # Strategy metadata methods
+
+        def strategy_name
+          "Model Associations (Class Diagram)"
+        end
+
+        def strategy_description
+          "Class diagram showing ActiveRecord model relationships and methods"
+        end
+
+        def mermaid_diagram_type
+          "classDiagram"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramStrategies
+      # Strategy for generating Entity Relationship Diagrams (ERD)
+      #
+      # 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
+
+        private
+
+        # Strategy metadata methods
+
+        def strategy_name
+          "Database Schema (ERD)"
+        end
+
+        def strategy_description
+          "Entity relationship diagram showing database tables and foreign key relationships"
+        end
+
+        def mermaid_diagram_type
+          "erDiagram"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramStrategies
+      # Strategy for generating flowchart diagrams from model associations
+      #
+      # 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
+
+        private
+
+        # Strategy metadata methods
+
+        def strategy_name
+          "Model Associations"
+        end
+
+        def strategy_description
+          "Flowchart diagram showing ActiveRecord model relationships and associations"
+        end
+
+        def mermaid_diagram_type
+          "flowchart"
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_system.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Diagram System Components
+# This file centralizes all diagram-related requires for better organization
+
+# Core diagram data structures
+require_relative "diagram_data"
+
+# Error handling
+require_relative "diagram_error_handler"
+
+# Registry and type management
+require_relative "diagram_type_registry"
+
+# Mermaid syntax generation
+require_relative "mermaid_syntax_builder"
+require_relative "mermaid_syntax/base_builder"
+require_relative "mermaid_syntax/sanitizer"
+require_relative "mermaid_syntax/cardinality_mapper"
+require_relative "mermaid_syntax/erd_builder"
+require_relative "mermaid_syntax/class_diagram_builder"
+require_relative "mermaid_syntax/flowchart_builder"
+
+# Diagram analyzers
+require_relative "diagram_analyzers/base_analyzer"
+require_relative "diagram_analyzers/foreign_key_analyzer"
+require_relative "diagram_analyzers/inferred_relationship_analyzer"
+require_relative "diagram_analyzers/model_association_analyzer"
+
+# Diagram strategies
+require_relative "diagram_strategies/base_diagram_strategy"
+require_relative "diagram_strategies/erd_diagram_strategy"
+require_relative "diagram_strategies/class_diagram_strategy"
+require_relative "diagram_strategies/flowchart_diagram_strategy"
+
+# Diagram generator (must be loaded after all components)
+require_relative "diagram_generator"
+
+module Dbwatcher
+  module Services
+    # Diagram System Module
+    # Provides centralized access to diagram generation capabilities
+    module DiagramSystem
+      # Get available diagram types
+      #
+      # @return [Array<String>] available diagram type names
+      def self.available_types
+        DiagramTypeRegistry.new.available_types
+      end
+
+      # Generate diagram for session
+      #
+      # @param session_id [String] session identifier
+      # @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
+      end
+
+      # Check if diagram type is supported
+      #
+      # @param diagram_type [String] diagram type to check
+      # @return [Boolean] true if supported
+      def self.supports?(diagram_type)
+        DiagramTypeRegistry.new.type_exists?(diagram_type)
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_type_registry.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    # Registry for managing diagram types and creating strategy instances
+    #
+    # Provides a central registry for all available diagram types with metadata,
+    # and factory methods for creating strategy instances.
+    class DiagramTypeRegistry
+      # Error classes for registry operations
+      class UnknownTypeError < StandardError; end
+
+      # Built-in diagram types with essential metadata
+      DIAGRAM_TYPES = {
+        "database_tables" => {
+          strategy_class: "Dbwatcher::Services::DiagramStrategies::ErdDiagramStrategy",
+          analyzer_class: "Dbwatcher::Services::DiagramAnalyzers::ForeignKeyAnalyzer",
+          display_name: "Database Schema",
+          description: "Entity relationship diagram showing database tables and foreign key relationships",
+          mermaid_type: "erDiagram"
+        },
+        "database_tables_inferred" => {
+          strategy_class: "Dbwatcher::Services::DiagramStrategies::ErdDiagramStrategy",
+          analyzer_class: "Dbwatcher::Services::DiagramAnalyzers::InferredRelationshipAnalyzer",
+          display_name: "Database Schema (Inferred)",
+          description: "Entity relationship diagram with inferred relationships from naming patterns",
+          mermaid_type: "erDiagram"
+        },
+        "model_associations" => {
+          strategy_class: "Dbwatcher::Services::DiagramStrategies::ClassDiagramStrategy",
+          analyzer_class: "Dbwatcher::Services::DiagramAnalyzers::ModelAssociationAnalyzer",
+          display_name: "Model Associations",
+          description: "Class diagram showing ActiveRecord models with attributes and methods",
+          mermaid_type: "classDiagram"
+        },
+        "model_associations_flowchart" => {
+          strategy_class: "Dbwatcher::Services::DiagramStrategies::FlowchartDiagramStrategy",
+          analyzer_class: "Dbwatcher::Services::DiagramAnalyzers::ModelAssociationAnalyzer",
+          display_name: "Model Associations (Flowchart)",
+          description: "Flowchart diagram showing model relationships",
+          mermaid_type: "flowchart"
+        }
+      }.freeze
+
+      # Initialize registry
+      def initialize
+        @logger = if defined?(Rails) && Rails.respond_to?(:logger)
+                    Rails.logger
+                  else
+                    require "logger"
+                    Logger.new($stdout)
+                  end
+      end
+
+      # Get list of available diagram type keys
+      #
+      # @return [Array<String>] diagram type keys
+      def available_types
+        DIAGRAM_TYPES.keys
+      end
+
+      # Get available types with metadata
+      #
+      # @return [Hash] diagram types with metadata
+      def available_types_with_metadata
+        DIAGRAM_TYPES.transform_values do |type_config|
+          type_config.except(:strategy_class, :analyzer_class)
+        end
+      end
+
+      # Create strategy instance for given type
+      #
+      # @param type [String] diagram type key
+      # @param dependencies [Hash] optional dependencies to inject
+      # @return [Object] strategy instance
+      # @raise [UnknownTypeError] if type is unknown
+      def create_strategy(type, dependencies = {})
+        type_config = find_type_config(type)
+        strategy_class = resolve_strategy_class(type_config[:strategy_class])
+
+        @logger.debug("Creating strategy for type #{type}: #{strategy_class.name}")
+        strategy_class.new(dependencies)
+      rescue StandardError => e
+        raise UnknownTypeError, "Cannot create strategy for type '#{type}': #{e.message}"
+      end
+
+      # Create analyzer instance for given type
+      #
+      # @param type [String] diagram type key
+      # @param session [Object] session object
+      # @return [Object] analyzer instance
+      # @raise [UnknownTypeError] if type is unknown
+      def create_analyzer(type, session)
+        type_config = find_type_config(type)
+        analyzer_class = resolve_analyzer_class(type_config[:analyzer_class])
+
+        @logger.debug("Creating analyzer for type #{type}: #{analyzer_class.name}")
+        analyzer_class.new(session)
+      rescue StandardError => e
+        raise UnknownTypeError, "Cannot create analyzer for type '#{type}': #{e.message}"
+      end
+
+      # Check if a diagram type exists
+      #
+      # @param type [String] diagram type key
+      # @return [Boolean] true if type exists
+      def type_exists?(type)
+        DIAGRAM_TYPES.key?(type)
+      end
+
+      # Get metadata for a specific diagram type
+      #
+      # @param type [String] diagram type key
+      # @return [Hash] type metadata
+      # @raise [UnknownTypeError] if type is unknown
+      def type_metadata(type)
+        type_config = find_type_config(type)
+        type_config.except(:strategy_class, :analyzer_class)
+      end
+
+      private
+
+      # Find type configuration by key
+      #
+      # @param type [String] diagram type key
+      # @return [Hash] type configuration
+      # @raise [UnknownTypeError] if type not found
+      def find_type_config(type)
+        type_config = DIAGRAM_TYPES[type]
+        raise UnknownTypeError, "Unknown diagram type: #{type}" unless type_config
+
+        type_config
+      end
+
+      # Resolve strategy class from string or class
+      #
+      # @param strategy_class [String, Class] strategy class reference
+      # @return [Class] resolved strategy class
+      def resolve_strategy_class(strategy_class)
+        if strategy_class.is_a?(String)
+          strategy_class.constantize
+        else
+          strategy_class
+        end
+      rescue NameError => e
+        raise UnknownTypeError, "Cannot resolve strategy class: #{e.message}"
+      end
+
+      # Resolve analyzer class from string or class
+      #
+      # @param analyzer_class [String, Class] analyzer class reference
+      # @return [Class] resolved analyzer class
+      def resolve_analyzer_class(analyzer_class)
+        if analyzer_class.is_a?(String)
+          analyzer_class.constantize
+        else
+          analyzer_class
+        end
+      rescue NameError => e
+        raise UnknownTypeError, "Cannot resolve analyzer class: #{e.message}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module MermaidSyntax
+      # Base class for Mermaid syntax builders
+      #
+      # Provides common functionality and configuration options for all Mermaid
+      # diagram builders. Subclasses should implement the build_from_dataset method.
+      #
+      # @example
+      #   class MyDiagramBuilder < BaseBuilder
+      #     def build_from_dataset(dataset)
+      #       # Implementation
+      #     end
+      #   end
+      class BaseBuilder
+        # Initialize a new builder with configuration
+        #
+        # @param config [Hash] configuration options
+        def initialize(config = {})
+          @config = default_config.merge(config)
+        end
+
+        # Build diagram content from dataset
+        #
+        # @param dataset [DiagramData::Dataset] dataset to render
+        # @return [String] Mermaid diagram content
+        def build_from_dataset(dataset)
+          raise NotImplementedError, "Subclasses must implement build_from_dataset"
+        end
+
+        # Build empty diagram with message
+        #
+        # @param message [String] message to display
+        # @return [String] Mermaid diagram content
+        def build_empty(message)
+          raise NotImplementedError, "Subclasses must implement build_empty"
+        end
+
+        protected
+
+        # Check if attributes should be shown
+        #
+        # @return [Boolean] true if attributes should be shown
+        def show_attributes?
+          @config[:show_attributes] == true
+        end
+
+        # Check if methods should be shown
+        #
+        # @return [Boolean] true if methods should be shown
+        def show_methods?
+          @config[:show_methods] == true
+        end
+
+        # Check if cardinality should be shown
+        #
+        # @return [Boolean] true if cardinality should be shown
+        def show_cardinality?
+          @config[:show_cardinality] != false
+        end
+
+        # Get maximum number of attributes to show
+        #
+        # @return [Integer] maximum number of attributes
+        def max_attributes
+          @config[:max_attributes] || 10
+        end
+
+        # Get maximum number of methods to show
+        #
+        # @return [Integer] maximum number of methods
+        def max_methods
+          @config[:max_methods] || 5
+        end
+
+        # Get diagram direction
+        #
+        # @return [String] diagram direction (TD, LR, etc.)
+        def diagram_direction
+          @config[:direction] || "LR"
+        end
+
+        # Check if table case should be preserved
+        #
+        # @return [Boolean] true if table case should be preserved
+        def preserve_table_case?
+          @config[:preserve_table_case] != false
+        end
+
+        # Get cardinality format
+        #
+        # @return [Symbol] cardinality format (:standard or :simple)
+        def cardinality_format
+          @config[:cardinality_format] || :simple
+        end
+
+        # Sanitize text for Mermaid
+        #
+        # @param text [String] text to sanitize
+        # @return [String] sanitized text
+        def sanitize_text(text)
+          return "" unless text
+
+          text.to_s.gsub(/["\n\r]/, " ").strip
+        end
+
+        # Default configuration options
+        #
+        # @return [Hash] default configuration
+        def default_config
+          {
+            show_attributes: true,
+            show_methods: false,
+            show_cardinality: true,
+            max_attributes: 10,
+            max_methods: 5,
+            direction: "LR",
+            preserve_table_case: true,
+            cardinality_format: :simple
+          }
+        end
+      end
+    end
+  end
+end