dbwatcher 1.0.0 → 1.1.1

data/lib/dbwatcher/services/mermaid_syntax_builder.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "set"
+require "digest"
+
+module Dbwatcher
+  module Services
+    # Builder for generating validated Mermaid diagram syntax
+    #
+    # Provides methods for building different types of Mermaid diagrams with
+    # syntax validation, error checking, and consistent formatting.
+    #
+    # @example
+    #   builder = MermaidSyntaxBuilder.new
+    #   content = builder.build_erd_diagram_from_dataset(dataset)
+    #   # => "erDiagram\n    USERS ||--o{ ORDERS : user_id"
+    class MermaidSyntaxBuilder
+      # Custom error classes
+      class SyntaxValidationError < StandardError; end
+      class UnsupportedDiagramTypeError < StandardError; end
+
+      # Supported Mermaid diagram types
+      SUPPORTED_DIAGRAM_TYPES = %w[erDiagram classDiagram flowchart graph].freeze
+
+      # Maximum content length to prevent memory issues
+      MAX_CONTENT_LENGTH = 100_000
+
+      # Initialize builder
+      #
+      # @param config [Hash] builder configuration (optional)
+      # @option config [Logger] :logger logger instance
+      def initialize(config = {})
+        @config = config
+        @logger = config[:logger] || Rails.logger
+      end
+
+      # Build ERD diagram from dataset
+      #
+      # @param dataset [DiagramData::Dataset] dataset to render
+      # @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"
+
+        builder = MermaidSyntax::ErdBuilder.new(@config.merge(options))
+        builder.build_from_dataset(dataset)
+      end
+
+      # Build class diagram from dataset
+      #
+      # @param dataset [DiagramData::Dataset] dataset to render
+      # @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"
+
+        builder = MermaidSyntax::ClassDiagramBuilder.new(@config.merge(options))
+        builder.build_from_dataset(dataset)
+      end
+
+      # Build flowchart diagram from dataset
+      #
+      # @param dataset [DiagramData::Dataset] dataset to render
+      # @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"
+
+        builder = MermaidSyntax::FlowchartBuilder.new(@config.merge(options))
+        builder.build_from_dataset(dataset)
+      end
+
+      # Build empty ERD diagram with message
+      #
+      # @param message [String] message to display
+      # @return [String] Mermaid ERD syntax
+      def build_empty_erd(message)
+        builder = MermaidSyntax::ErdBuilder.new(@config)
+        builder.build_empty(message)
+      end
+
+      # Build empty flowchart diagram with message
+      #
+      # @param message [String] message to display
+      # @return [String] Mermaid flowchart syntax
+      def build_empty_flowchart(message)
+        builder = MermaidSyntax::FlowchartBuilder.new(@config)
+        builder.build_empty(message)
+      end
+
+      # Build empty class diagram with message
+      #
+      # @param message [String] message to display
+      # @return [String] Mermaid class diagram syntax
+      def build_empty_class_diagram(message)
+        builder = MermaidSyntax::ClassDiagramBuilder.new(@config)
+        builder.build_empty(message)
+      end
+
+      # Build empty diagram of specified type
+      #
+      # @param message [String] message to display
+      # @param diagram_type [String] type of diagram
+      # @return [String] Mermaid syntax
+      # @raise [UnsupportedDiagramTypeError] if type unsupported
+      def build_empty_diagram(message, diagram_type)
+        case diagram_type
+        when "erDiagram", "erd"
+          build_empty_erd(message)
+        when "classDiagram", "class"
+          build_empty_class_diagram(message)
+        when "flowchart", "graph"
+          build_empty_flowchart(message)
+        else
+          raise UnsupportedDiagramTypeError, "Unsupported diagram type: #{diagram_type}"
+        end
+      end
+
+      # Build ERD diagram with isolated tables
+      #
+      # @param entities [Array<Entity>] isolated table entities
+      # @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"
+
+        dataset = Dbwatcher::Services::DiagramData::Dataset.new
+        entities.each { |entity| dataset.add_entity(entity) }
+
+        build_erd_diagram_from_dataset(dataset, options)
+      end
+
+      # Build flowchart diagram with isolated nodes
+      #
+      # @param entities [Array<Entity>] isolated node entities
+      # @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"
+
+        dataset = Dbwatcher::Services::DiagramData::Dataset.new
+        entities.each { |entity| dataset.add_entity(entity) }
+
+        build_flowchart_diagram_from_dataset(dataset, options)
+      end
+
+      # For backward compatibility with legacy code
+      alias build_erd_diagram build_erd_diagram_from_dataset
+      alias build_flowchart_diagram build_flowchart_diagram_from_dataset
+    end
+  end
+end

data/lib/dbwatcher/storage/api/concerns/table_analyzer.rb

@@ -6,8 +6,8 @@ module Dbwatcher
       module Concerns
         # Provides reusable table analysis functionality for API classes
         #
-        # This concern extracts common table analysis logic used by API classes
-        # to avoid duplication and provide consistent table analysis capabilities.
+        # This concern now acts as a facade, delegating specific responsibilities
+        # to specialized service classes while maintaining backward compatibility.
         #
         # @example
         #   class MyAPI < BaseAPI
@@ -23,148 +23,35 @@ module Dbwatcher
           # @param session [Session] session to analyze
           # @return [Hash] tables summary hash
           def build_tables_summary(session)
-            tables = {}
-            process_session_changes(session, tables)
-            tables
+            # Delegate to new service while maintaining interface compatibility
+            Dbwatcher::Services::Analyzers::TableSummaryBuilder.call(session)
           end
 
-          # Process all changes in a session
+          # Process all changes in a session (legacy method for backward compatibility)
           #
           # @param session [Session] session with changes
-          # @param tables [Hash] tables hash to populate
+          # @param _tables [Hash] tables hash to populate (unused but kept for compatibility)
           # @return [void]
-          def process_session_changes(session, tables)
-            return unless session&.changes.respond_to?(:each)
-
-            session.changes.each do |change|
-              table_name = extract_table_name(change)
-              next unless table_name
-
-              initialize_table_data(tables, table_name)
-              update_table_data(tables[table_name], change)
-              update_sample_record(tables[table_name], change)
+          def process_session_changes(session, _tables)
+            # Use new service for processing but maintain yield interface
+            processor = Dbwatcher::Services::Analyzers::SessionDataProcessor.new(session)
+            processor.process_changes do |table_name, change, _|
+              yield(table_name, change) if block_given?
             end
           end
 
-          # Extract table name from change data
+          # Legacy methods maintained for backward compatibility
+          # These now delegate to the new service classes
+
+          # Extract table name from change data (legacy compatibility)
           #
           # @param change [Hash] change data
           # @return [String, nil] table name or nil
           def extract_table_name(change)
             return nil unless change.is_a?(Hash)
 
-            # Only use symbols since data is normalized
             change[:table_name]
           end
-
-          # Initialize table data structure
-          #
-          # @param tables [Hash] tables hash
-          # @param table_name [String] table name
-          # @return [void]
-          def initialize_table_data(tables, table_name)
-            tables[table_name] ||= {
-              name: table_name,
-              operations: { "INSERT" => 0, "UPDATE" => 0, "DELETE" => 0 },
-              changes: [],
-              sample_record: nil,
-              records: {},
-              relationships: []
-            }
-          end
-
-          # Update table data with change information
-          #
-          # @param table_data [Hash] table data hash
-          # @param change [Hash] change data
-          # @return [void]
-          def update_table_data(table_data, change)
-            # Count operations
-            operation = extract_operation(change)
-            table_data[:operations][operation] ||= 0
-            table_data[:operations][operation] += 1
-
-            # Add change to the list
-            table_data[:changes] << change
-          end
-
-          # Update sample record if not already set
-          #
-          # @param table_data [Hash] table data hash
-          # @param change [Hash] change data
-          # @return [void]
-          def update_sample_record(table_data, change)
-            return unless table_data[:sample_record].nil?
-
-            snapshot = extract_record_snapshot(change)
-            table_data[:sample_record] = snapshot if snapshot
-          end
-
-          # Update record history for analysis
-          #
-          # @param table_data [Hash] table data hash
-          # @param change [Hash] change data
-          # @return [void]
-          def update_record_history(table_data, change)
-            record_id = extract_record_id(change)
-            return unless record_id
-
-            table_data[:records][record_id] ||= []
-            table_data[:records][record_id] << {
-              operation: extract_operation(change),
-              timestamp: extract_timestamp(change),
-              changes: extract_field_changes(change)
-            }
-          end
-
-          private
-
-          # Extract operation from change data
-          #
-          # @param change [Hash] change data
-          # @return [String] operation string
-          def extract_operation(change)
-            # Only use symbols since data is normalized
-            operation = change[:operation] || "UNKNOWN"
-            operation.to_s.upcase
-          end
-
-          # Extract record snapshot from change data
-          #
-          # @param change [Hash] change data
-          # @return [Hash, nil] record snapshot or nil
-          def extract_record_snapshot(change)
-            # Only use symbols since data is normalized
-            change[:record_snapshot]
-          end
-
-          # Extract record ID from change data
-          #
-          # @param change [Hash] change data
-          # @return [String, nil] record ID or nil
-          def extract_record_id(change)
-            # Only use symbols since data is normalized
-            id = change[:record_id]
-            id&.to_s
-          end
-
-          # Extract timestamp from change data
-          #
-          # @param change [Hash] change data
-          # @return [String, nil] timestamp string or nil
-          def extract_timestamp(change)
-            # Only use symbols since data is normalized
-            change[:timestamp]
-          end
-
-          # Extract field changes from change data
-          #
-          # @param change [Hash] change data
-          # @return [Hash] field changes hash
-          def extract_field_changes(change)
-            # Only use symbols since data is normalized
-            change[:changes] || {}
-          end
         end
       end
     end

data/lib/dbwatcher/storage/api/session_api.rb

@@ -91,6 +91,42 @@ module Dbwatcher
             .first(limit)
         end
 
+        # Get comprehensive session analysis including tables and relationships
+        #
+        # @param session_id [String] session identifier
+        # @return [Hash] session analysis data
+        def summary(session_id)
+          session = find(session_id)
+          return { error: "Session not found" } unless session
+
+          {
+            tables_summary: tables_summary(session_id),
+            total_changes: session.changes&.count || 0,
+            session_metadata: extract_session_metadata(session)
+          }
+        end
+
+        # Get tables summary for a session
+        #
+        # @param session_id [String] session identifier
+        # @return [Hash] tables summary
+        def tables_summary(session_id)
+          session = find(session_id)
+          return { error: "Session not found" } unless session
+
+          analyzer = Dbwatcher::Services::Analyzers::TableSummaryBuilder.new(session)
+          analyzer.call
+        end
+
+        # Generate diagram data for a session
+        #
+        # @param session_id [String] session identifier
+        # @param diagram_type [String] type of diagram to generate
+        # @return [Hash] diagram data
+        def diagram_data(session_id, diagram_type = "database_tables")
+          Dbwatcher::Services::DiagramSystem.generate(session_id, diagram_type)
+        end
+
         private
 
         def apply_filters(sessions)
@@ -128,6 +164,17 @@ module Dbwatcher
             session&.changes&.any?
           end
         end
+
+        # Extract session metadata for analysis
+        #
+        # @param session [Session] session object
+        # @return [Hash] metadata hash
+        def extract_session_metadata(session)
+          {
+            id: session.id,
+            changes_count: session.changes&.count || 0
+          }
+        end
       end
     end
   end

data/lib/dbwatcher/storage/base_storage.rb

@@ -47,8 +47,15 @@ module Dbwatcher
       # instance, and initializes timestamps.
       #
       # @param storage_path [String, nil] custom storage path (optional)
+      # @raise [StorageError] if storage_path is nil or empty
       def initialize(storage_path = nil)
         @storage_path = storage_path || Dbwatcher.configuration.storage_path
+
+        # Ensure storage path is valid
+        if @storage_path.nil? || @storage_path.to_s.strip.empty?
+          raise StorageError, "Storage path cannot be nil or empty. Please configure a valid storage path."
+        end
+
         @file_manager = FileManager.new(@storage_path)
         initialize_timestamps
         ensure_storage_directory

data/lib/dbwatcher/version.rb

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

data/lib/dbwatcher.rb

@@ -5,17 +5,74 @@ require "fileutils"
 require "securerandom"
 require "singleton"
 require "logger"
+
+# Core components
 require_relative "dbwatcher/version"
 require_relative "dbwatcher/configuration"
 require_relative "dbwatcher/logging"
-require_relative "dbwatcher/tracker"
+
+# Storage layer
 require_relative "dbwatcher/storage"
+
+# Tracking and SQL monitoring
+require_relative "dbwatcher/tracker"
 require_relative "dbwatcher/sql_logger"
 require_relative "dbwatcher/model_extension"
 require_relative "dbwatcher/middleware"
+
+# Base services
+require_relative "dbwatcher/services/base_service"
+
+# Core services
 require_relative "dbwatcher/services/table_statistics_collector"
 require_relative "dbwatcher/services/dashboard_data_aggregator"
 require_relative "dbwatcher/services/query_filter_processor"
+
+# General analyzers
+require_relative "dbwatcher/services/analyzers/session_data_processor"
+require_relative "dbwatcher/services/analyzers/table_summary_builder"
+
+# Diagram data models
+require_relative "dbwatcher/services/diagram_data/attribute"
+require_relative "dbwatcher/services/diagram_data/entity"
+require_relative "dbwatcher/services/diagram_data/relationship"
+require_relative "dbwatcher/services/diagram_data/dataset"
+require_relative "dbwatcher/services/diagram_data"
+
+# Diagram analyzers
+require_relative "dbwatcher/services/diagram_analyzers/base_analyzer"
+require_relative "dbwatcher/services/diagram_analyzers/foreign_key_analyzer"
+require_relative "dbwatcher/services/diagram_analyzers/inferred_relationship_analyzer"
+require_relative "dbwatcher/services/diagram_analyzers/model_association_analyzer"
+
+# Mermaid syntax builders
+require_relative "dbwatcher/services/mermaid_syntax/base_builder"
+require_relative "dbwatcher/services/mermaid_syntax/sanitizer"
+require_relative "dbwatcher/services/mermaid_syntax/cardinality_mapper"
+require_relative "dbwatcher/services/mermaid_syntax/erd_builder"
+require_relative "dbwatcher/services/mermaid_syntax/class_diagram_builder"
+require_relative "dbwatcher/services/mermaid_syntax/flowchart_builder"
+require_relative "dbwatcher/services/mermaid_syntax_builder"
+
+# Diagram strategies
+require_relative "dbwatcher/services/diagram_strategies/base_diagram_strategy"
+require_relative "dbwatcher/services/diagram_strategies/erd_diagram_strategy"
+require_relative "dbwatcher/services/diagram_strategies/class_diagram_strategy"
+require_relative "dbwatcher/services/diagram_strategies/flowchart_diagram_strategy"
+
+# Diagram system
+require_relative "dbwatcher/services/diagram_error_handler"
+require_relative "dbwatcher/services/diagram_type_registry"
+require_relative "dbwatcher/services/diagram_generator"
+require_relative "dbwatcher/services/diagram_system"
+
+# API services
+require_relative "dbwatcher/services/api/base_api_service"
+require_relative "dbwatcher/services/api/changes_data_service"
+require_relative "dbwatcher/services/api/summary_data_service"
+require_relative "dbwatcher/services/api/diagram_data_service"
+
+# Rails engine
 require_relative "dbwatcher/engine" if defined?(Rails)
 
 module Dbwatcher

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbwatcher
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Huy Nguyen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-15 00:00:00.000000000 Z
+date: 2025-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: sassc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
@@ -141,6 +155,7 @@ description: DB Watcher helps developers debug Rails applications by tracking al
 email:
 - patrick204nqh@gmail.com
 executables:
+- compile_scss
 - console
 - release
 - setup
@@ -149,18 +164,61 @@ extra_rdoc_files: []
 files:
 - README.md
 - Rakefile
+- app/assets/config/dbwatcher_manifest.js
+- app/assets/javascripts/dbwatcher/alpine_registrations.js
+- app/assets/javascripts/dbwatcher/auto_init.js
+- app/assets/javascripts/dbwatcher/components/base.js
+- app/assets/javascripts/dbwatcher/components/changes_table_hybrid.js
+- app/assets/javascripts/dbwatcher/components/diagrams.js
+- app/assets/javascripts/dbwatcher/components/summary.js
+- app/assets/javascripts/dbwatcher/core/alpine_store.js
+- app/assets/javascripts/dbwatcher/core/api_client.js
+- app/assets/javascripts/dbwatcher/core/component_loader.js
+- app/assets/javascripts/dbwatcher/core/component_registry.js
+- app/assets/javascripts/dbwatcher/dbwatcher.js
+- app/assets/javascripts/dbwatcher/services/mermaid.js
+- app/assets/javascripts/dbwatcher/services/mermaid_service.js
+- app/assets/javascripts/dbwatcher/vendor/date-fns-browser.js
+- app/assets/javascripts/dbwatcher/vendor/lodash.min.js
+- app/assets/javascripts/dbwatcher/vendor/tabulator.min.js
+- app/assets/stylesheets/dbwatcher/application.css
+- app/assets/stylesheets/dbwatcher/application.scss
+- app/assets/stylesheets/dbwatcher/components/_badges.scss
+- app/assets/stylesheets/dbwatcher/components/_compact_table.scss
+- app/assets/stylesheets/dbwatcher/components/_diagrams.scss
+- app/assets/stylesheets/dbwatcher/components/_forms.scss
+- app/assets/stylesheets/dbwatcher/components/_navigation.scss
+- app/assets/stylesheets/dbwatcher/core/_base.scss
+- app/assets/stylesheets/dbwatcher/core/_variables.scss
+- app/assets/stylesheets/dbwatcher/vendor/tabulator.min.css
+- app/controllers/dbwatcher/api/v1/sessions_controller.rb
 - app/controllers/dbwatcher/base_controller.rb
 - app/controllers/dbwatcher/dashboard_controller.rb
 - app/controllers/dbwatcher/queries_controller.rb
 - app/controllers/dbwatcher/sessions_controller.rb
 - app/controllers/dbwatcher/tables_controller.rb
 - app/helpers/dbwatcher/application_helper.rb
+- app/helpers/dbwatcher/component_helper.rb
+- app/helpers/dbwatcher/diagram_helper.rb
 - app/helpers/dbwatcher/formatting_helper.rb
 - app/helpers/dbwatcher/session_helper.rb
 - app/views/dbwatcher/dashboard/index.html.erb
 - app/views/dbwatcher/queries/index.html.erb
+- app/views/dbwatcher/sessions/_changes_tab.html.erb
+- app/views/dbwatcher/sessions/_diagrams_tab.html.erb
+- app/views/dbwatcher/sessions/_session_header.html.erb
+- app/views/dbwatcher/sessions/_summary_tab.html.erb
+- app/views/dbwatcher/sessions/_tab_navigation.html.erb
+- app/views/dbwatcher/sessions/changes.html.erb
+- app/views/dbwatcher/sessions/components/changes/_filters.html.erb
+- app/views/dbwatcher/sessions/components/changes/_table_list.html.erb
+- app/views/dbwatcher/sessions/diagrams.html.erb
 - app/views/dbwatcher/sessions/index.html.erb
+- app/views/dbwatcher/sessions/shared/_layout.html.erb
+- app/views/dbwatcher/sessions/shared/_navigation.html.erb
+- app/views/dbwatcher/sessions/shared/_session_header.html.erb
 - app/views/dbwatcher/sessions/show.html.erb
+- app/views/dbwatcher/sessions/summary.html.erb
 - app/views/dbwatcher/shared/_badge.html.erb
 - app/views/dbwatcher/shared/_data_table.html.erb
 - app/views/dbwatcher/shared/_header.html.erb
@@ -172,6 +230,7 @@ files:
 - app/views/dbwatcher/tables/index.html.erb
 - app/views/dbwatcher/tables/show.html.erb
 - app/views/layouts/dbwatcher/application.html.erb
+- bin/compile_scss
 - bin/console
 - bin/release
 - bin/setup
@@ -182,7 +241,40 @@ files:
 - lib/dbwatcher/logging.rb
 - lib/dbwatcher/middleware.rb
 - lib/dbwatcher/model_extension.rb
+- lib/dbwatcher/services/analyzers/session_data_processor.rb
+- lib/dbwatcher/services/analyzers/table_summary_builder.rb
+- lib/dbwatcher/services/api/base_api_service.rb
+- lib/dbwatcher/services/api/changes_data_service.rb
+- lib/dbwatcher/services/api/diagram_data_service.rb
+- lib/dbwatcher/services/api/summary_data_service.rb
+- lib/dbwatcher/services/base_service.rb
 - lib/dbwatcher/services/dashboard_data_aggregator.rb
+- lib/dbwatcher/services/diagram_analyzers/base_analyzer.rb
+- lib/dbwatcher/services/diagram_analyzers/foreign_key_analyzer.rb
+- lib/dbwatcher/services/diagram_analyzers/inferred_relationship_analyzer.rb
+- lib/dbwatcher/services/diagram_analyzers/model_association_analyzer.rb
+- lib/dbwatcher/services/diagram_data.rb
+- lib/dbwatcher/services/diagram_data/attribute.rb
+- lib/dbwatcher/services/diagram_data/dataset.rb
+- lib/dbwatcher/services/diagram_data/entity.rb
+- lib/dbwatcher/services/diagram_data/relationship.rb
+- lib/dbwatcher/services/diagram_data/relationship_params.rb
+- lib/dbwatcher/services/diagram_error_handler.rb
+- 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/erd_diagram_strategy.rb
+- lib/dbwatcher/services/diagram_strategies/flowchart_diagram_strategy.rb
+- lib/dbwatcher/services/diagram_system.rb
+- lib/dbwatcher/services/diagram_type_registry.rb
+- lib/dbwatcher/services/mermaid_syntax/base_builder.rb
+- lib/dbwatcher/services/mermaid_syntax/cardinality_mapper.rb
+- lib/dbwatcher/services/mermaid_syntax/class_diagram_builder.rb
+- lib/dbwatcher/services/mermaid_syntax/class_diagram_helper.rb
+- lib/dbwatcher/services/mermaid_syntax/erd_builder.rb
+- lib/dbwatcher/services/mermaid_syntax/flowchart_builder.rb
+- lib/dbwatcher/services/mermaid_syntax/sanitizer.rb
+- lib/dbwatcher/services/mermaid_syntax_builder.rb
 - lib/dbwatcher/services/query_filter_processor.rb
 - lib/dbwatcher/services/table_statistics_collector.rb
 - lib/dbwatcher/sql_logger.rb