dbwatcher 1.1.4 → 1.1.5

data/lib/dbwatcher/services/diagram_data/attribute.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "base"
+
 module Dbwatcher
   module Services
     module DiagramData
@@ -18,7 +20,7 @@ module Dbwatcher
       #   )
       #   attribute.valid? # => true
       #   attribute.to_h   # => { name: "email", type: "string", ... }
-      class Attribute
+      class Attribute < Base
         attr_accessor :name, :type, :nullable, :default, :metadata
 
         # Initialize attribute
@@ -29,6 +31,7 @@ module Dbwatcher
         # @param default [Object] default value
         # @param metadata [Hash] additional type-specific information
         def initialize(name:, type: nil, nullable: true, default: nil, metadata: {})
+          super() # Initialize parent class
           @name = name.to_s
           @type = type.to_s
           @nullable = nullable == true
@@ -36,16 +39,23 @@ module Dbwatcher
           @metadata = metadata.is_a?(Hash) ? metadata : {}
         end
 
-        # Check if attribute is valid
-        #
-        # @return [Boolean] true if attribute has required fields
-        def valid?
-          validation_errors.empty?
+        # Implementation for Base class
+        def comparable_attributes
+          [name, type, nullable, default, metadata]
         end
 
-        # Get validation errors
-        #
-        # @return [Array<String>] array of validation error messages
+        # Implementation for Base class
+        def serializable_attributes
+          {
+            name: name,
+            type: type,
+            nullable: nullable,
+            default: default,
+            metadata: metadata
+          }
+        end
+
+        # Implementation for Base class
         def validation_errors
           errors = []
           errors << "Name cannot be blank" if name.nil? || name.to_s.strip.empty?
@@ -67,86 +77,15 @@ module Dbwatcher
           metadata[:foreign_key] == true || name.to_s.end_with?("_id")
         end
 
-        # Serialize attribute to hash
-        #
-        # @return [Hash] serialized attribute data
-        def to_h
+        # Override base class method to handle nullable default
+        def self.extract_constructor_args(hash)
           {
-            name: name,
-            type: type,
-            nullable: nullable,
-            default: default,
-            metadata: metadata
-          }
-        end
-
-        # Serialize attribute to JSON
-        #
-        # @return [String] JSON representation
-        def to_json(*args)
-          to_h.to_json(*args)
-        end
-
-        # Create attribute from hash
-        #
-        # @param hash [Hash] attribute data
-        # @return [Attribute] new attribute instance
-        def self.from_h(hash)
-          # Convert string keys to symbols for consistent access
-          hash = hash.transform_keys(&:to_sym) if hash.keys.first.is_a?(String)
-
-          # Use fetch with default values to handle missing fields
-          new(
             name: hash[:name],
             type: hash[:type],
             nullable: hash.key?(:nullable) ? hash[:nullable] : true,
             default: hash[:default],
             metadata: hash[:metadata] || {}
-          )
-        end
-
-        # Create attribute from JSON
-        #
-        # @param json [String] JSON string
-        # @return [Attribute] new attribute instance
-        def self.from_json(json)
-          from_h(JSON.parse(json))
-        end
-
-        # Check equality with another attribute
-        #
-        # @param other [Attribute] other attribute to compare
-        # @return [Boolean] true if attributes are equal
-        def ==(other)
-          return false unless other.is_a?(Attribute)
-
-          name == other.name &&
-            type == other.type &&
-            nullable == other.nullable &&
-            default == other.default &&
-            metadata == other.metadata
-        end
-
-        # Generate hash code for attribute
-        #
-        # @return [Integer] hash code
-        def hash
-          [name, type, nullable, default, metadata].hash
-        end
-
-        # String representation of attribute
-        #
-        # @return [String] string representation
-        def to_s
-          "#{self.class.name}(name: #{name}, type: #{type}, nullable: #{nullable})"
-        end
-
-        # Detailed string representation
-        #
-        # @return [String] detailed string representation
-        def inspect
-          "#{self.class.name}(name: #{name.inspect}, type: #{type.inspect}, " \
-            "nullable: #{nullable.inspect}, default: #{default.inspect}, metadata: #{metadata.inspect})"
+          }
         end
       end
     end

data/lib/dbwatcher/services/diagram_data/base.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Dbwatcher
+  module Services
+    module DiagramData
+      # Base class for diagram data objects
+      #
+      # Provides common functionality for serialization, validation, and comparison
+      # that is shared across Attribute, Entity, and Relationship classes.
+      #
+      # Subclasses must implement:
+      # - comparable_attributes: Array of values used for equality comparison
+      # - serializable_attributes: Hash of attributes for serialization
+      # - validation_errors: Array of validation error strings (optional)
+      #
+      # @example
+      #   class MyClass < Base
+      #     def comparable_attributes
+      #       [name, type, value]
+      #     end
+      #
+      #     def serializable_attributes
+      #       { name: name, type: type, value: value }
+      #     end
+      #   end
+      class Base
+        # Check if object is valid
+        #
+        # @return [Boolean] true if object has no validation errors
+        def valid?
+          validation_errors.empty?
+        end
+
+        # Check equality with another object of the same class
+        #
+        # @param other [Object] object to compare with
+        # @return [Boolean] true if objects are equal
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          comparable_attributes == other.comparable_attributes
+        end
+
+        # Generate hash code for object
+        #
+        # @return [Integer] hash code
+        def hash
+          comparable_attributes.hash
+        end
+
+        # Serialize object to hash
+        #
+        # @return [Hash] serialized object data
+        def to_h
+          serializable_attributes
+        end
+
+        # Serialize object to JSON
+        #
+        # @return [String] JSON representation
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+
+        # Create object from hash
+        #
+        # @param hash [Hash] object data
+        # @return [Object] new object instance
+        def self.from_h(hash)
+          # Convert string keys to symbols for consistent access
+          hash = hash.transform_keys(&:to_sym) if hash.respond_to?(:transform_keys) && hash.keys.first.is_a?(String)
+
+          new(**extract_constructor_args(hash))
+        end
+
+        # Create object from JSON
+        #
+        # @param json [String] JSON string
+        # @return [Object] new object instance
+        def self.from_json(json)
+          from_h(JSON.parse(json))
+        end
+
+        # String representation of object
+        #
+        # @return [String] string representation
+        def to_s
+          attrs = serializable_attributes.map { |k, v| "#{k}: #{v}" }.join(", ")
+          "#{self.class.name}(#{attrs})"
+        end
+
+        # Detailed string representation
+        #
+        # @return [String] detailed string representation
+        def inspect
+          attrs = serializable_attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+          "#{self.class.name}(#{attrs})"
+        end
+
+        # Default implementation - subclasses should override
+        def comparable_attributes
+          raise NotImplementedError, "#{self.class} must implement #comparable_attributes"
+        end
+
+        # Default implementation - subclasses should override
+        def serializable_attributes
+          raise NotImplementedError, "#{self.class} must implement #serializable_attributes"
+        end
+
+        # Default implementation - subclasses should override if validation needed
+        def validation_errors
+          []
+        end
+
+        # Extract constructor arguments from hash
+        # Subclasses can override this for custom initialization logic
+        #
+        # @param hash [Hash] object data
+        # @return [Hash] constructor arguments
+        def self.extract_constructor_args(hash)
+          hash
+        end
+        private_class_method :extract_constructor_args
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_data/entity.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "base"
+
 module Dbwatcher
   module Services
     module DiagramData
@@ -20,7 +22,7 @@ module Dbwatcher
       #   )
       #   entity.valid? # => true
       #   entity.to_h   # => { id: "users", name: "User", ... }
-      class Entity
+      class Entity < Base
         attr_accessor :id, :name, :type, :attributes, :metadata
 
         # Initialize entity
@@ -31,6 +33,7 @@ module Dbwatcher
         # @param attributes [Array<Attribute>] entity attributes/properties
         # @param metadata [Hash] additional type-specific information
         def initialize(id:, name:, type: "default", attributes: [], metadata: {})
+          super() # Initialize parent class
           @id = id.to_s
           @name = name.to_s
           @type = type.to_s
@@ -38,16 +41,23 @@ module Dbwatcher
           @metadata = metadata.is_a?(Hash) ? metadata : {}
         end
 
-        # Check if entity is valid
-        #
-        # @return [Boolean] true if entity has required fields
-        def valid?
-          validation_errors.empty?
+        # Implementation for Base class
+        def comparable_attributes
+          [id, name, type, attributes, metadata]
         end
 
-        # Get validation errors
-        #
-        # @return [Array<String>] array of validation error messages
+        # Implementation for Base class
+        def serializable_attributes
+          {
+            id: id,
+            name: name,
+            type: type,
+            attributes: attributes.map(&:to_h),
+            metadata: metadata
+          }
+        end
+
+        # Implementation for Base class
         def validation_errors
           errors = []
           errors << "ID cannot be blank" if id.nil? || id.to_s.strip.empty?
@@ -91,80 +101,21 @@ module Dbwatcher
           attributes.select(&:foreign_key?)
         end
 
-        # Serialize entity to hash
-        #
-        # @return [Hash] serialized entity data
-        def to_h
-          {
-            id: id,
-            name: name,
-            type: type,
-            attributes: attributes.map(&:to_h),
-            metadata: metadata
-          }
-        end
-
-        # Serialize entity to JSON
-        #
-        # @return [String] JSON representation
-        def to_json(*args)
-          to_h.to_json(*args)
-        end
-
-        # Create entity from hash
-        #
-        # @param hash [Hash] entity data
-        # @return [Entity] new entity instance
-        def self.from_h(hash)
+        # Override base class method to handle attributes array
+        def self.extract_constructor_args(hash)
           attrs = []
           if hash[:attributes] || hash["attributes"]
             attr_data = hash[:attributes] || hash["attributes"]
             attrs = attr_data.map { |attr| Attribute.from_h(attr) }
           end
 
-          new(
+          {
             id: hash[:id] || hash["id"],
             name: hash[:name] || hash["name"],
             type: hash[:type] || hash["type"] || "default",
             attributes: attrs,
             metadata: hash[:metadata] || hash["metadata"] || {}
-          )
-        end
-
-        # Create entity from JSON
-        #
-        # @param json [String] JSON string
-        # @return [Entity] new entity instance
-        def self.from_json(json)
-          from_h(JSON.parse(json))
-        end
-
-        # Check equality with another entity
-        #
-        # @param other [Entity] other entity to compare
-        # @return [Boolean] true if entities are equal
-        def ==(other)
-          return false unless other.is_a?(Entity)
-
-          id == other.id &&
-            name == other.name &&
-            type == other.type &&
-            attributes == other.attributes &&
-            metadata == other.metadata
-        end
-
-        # Generate hash code for entity
-        #
-        # @return [Integer] hash code
-        def hash
-          [id, name, type, attributes, metadata].hash
-        end
-
-        # String representation of entity
-        #
-        # @return [String] string representation
-        def to_s
-          "#{self.class.name}(id: #{id}, name: #{name}, type: #{type})"
+          }
         end
 
         # Detailed string representation

data/lib/dbwatcher/services/diagram_data/relationship.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "base"
 require_relative "relationship_params"
 
 module Dbwatcher
@@ -21,7 +22,7 @@ module Dbwatcher
       #   )
       #   relationship.valid? # => true
       #   relationship.to_h   # => { source_id: "users", target_id: "orders", ... }
-      class Relationship
+      class Relationship < Base
         attr_accessor :source_id, :target_id, :type, :label, :cardinality, :metadata
 
         # Valid cardinality types
@@ -57,6 +58,7 @@ module Dbwatcher
         # @param params [RelationshipParams, Hash] relationship parameters
         # @return [Relationship] new relationship instance
         def initialize(params)
+          super() # Initialize parent class
           params = RelationshipParams.new(params) if params.is_a?(Hash)
 
           @source_id = params.source_id.to_s
@@ -108,10 +110,18 @@ module Dbwatcher
           ERD_NOTATIONS[infer_cardinality] || DEFAULT_ERD_NOTATION
         end
 
-        # Serialize relationship to hash
-        #
-        # @return [Hash] serialized relationship data
-        def to_h
+        # Override base class method to handle simple hash initialization
+        def self.extract_constructor_args(hash)
+          hash
+        end
+
+        # Implementation for Base class
+        def comparable_attributes
+          [source_id, target_id, type, label, cardinality, metadata]
+        end
+
+        # Implementation for Base class
+        def serializable_attributes
           {
             source_id: source_id,
             target_id: target_id,
@@ -121,67 +131,6 @@ module Dbwatcher
             metadata: metadata
           }
         end
-
-        # Serialize relationship to JSON
-        #
-        # @return [String] JSON representation
-        def to_json(*args)
-          to_h.to_json(*args)
-        end
-
-        # Create relationship from hash
-        #
-        # @param hash [Hash] relationship data
-        # @return [Relationship] new relationship instance
-        def self.from_h(hash)
-          hash = hash.transform_keys(&:to_sym) if hash.keys.first.is_a?(String)
-          new(hash)
-        end
-
-        # Create relationship from JSON
-        #
-        # @param json [String] JSON string
-        # @return [Relationship] new relationship instance
-        def self.from_json(json)
-          from_h(JSON.parse(json))
-        end
-
-        # Check equality with another relationship
-        #
-        # @param other [Relationship] other relationship to compare
-        # @return [Boolean] true if relationships are equal
-        def ==(other)
-          return false unless other.is_a?(Relationship)
-
-          source_id == other.source_id &&
-            target_id == other.target_id &&
-            type == other.type &&
-            label == other.label &&
-            cardinality == other.cardinality &&
-            metadata == other.metadata
-        end
-
-        # Generate hash code for relationship
-        #
-        # @return [Integer] hash code
-        def hash
-          [source_id, target_id, type, label, cardinality, metadata].hash
-        end
-
-        # String representation of relationship
-        #
-        # @return [String] string representation
-        def to_s
-          "#{self.class.name}(source: #{source_id}, target: #{target_id}, type: #{type})"
-        end
-
-        # Detailed string representation
-        #
-        # @return [String] detailed string representation
-        def inspect
-          "#{self.class.name}(source: #{source_id.inspect}, target: #{target_id.inspect}, " \
-            "type: #{type.inspect}, label: #{label.inspect}, cardinality: #{cardinality.inspect})"
-        end
       end
     end
   end

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

@@ -70,7 +70,7 @@ module Dbwatcher
         # @param entity [DiagramData::Entity] entity to render
         # @return [Array<String>] entity definition lines
         def build_erd_entity(entity)
-          table_name = Sanitizer.table_name(entity.name, preserve_table_case?)
+          table_name = Sanitizer.table_name(entity.name)
           lines = ["    #{table_name} {"]
 
           # Add attributes if enabled and available
@@ -92,7 +92,7 @@ module Dbwatcher
         # @return [String] formatted entity name
         def format_entity_name(entity_id, dataset)
           entity_name = dataset.get_entity(entity_id)&.name || entity_id
-          Sanitizer.table_name(entity_name, preserve_table_case?)
+          Sanitizer.table_name(entity_name)
         end
 
         # Build relationship definition

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

@@ -48,22 +48,12 @@ module Dbwatcher
           # Sanitize table name for Mermaid ERD
           #
           # @param name [String] raw table name
-          # @param preserve_case [Boolean] whether to preserve original case
-          # @return [String] sanitized table name
-          def table_name(name, preserve_case = nil)
+          # @return [String] sanitized table name (preserves original case)
+          def table_name(name)
             return "UNKNOWN_TABLE" unless name.is_a?(String) && !name.empty?
 
-            preserve = if preserve_case.nil?
-                         Dbwatcher.configuration.diagram_preserve_table_case
-                       else
-                         preserve_case
-                       end
-
-            if preserve
-              name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
-            else
-              name.to_s.upcase.gsub(/[^A-Z0-9_]/, "_")
-            end
+            # Always preserve original case
+            name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
           end
 
           # Sanitize method name for Mermaid class diagrams

data/lib/dbwatcher/services/system_info/runtime_info_collector.rb

@@ -136,7 +136,7 @@ module Dbwatcher
         #
         # @return [Hash] loaded gems with versions
         def collect_loaded_gems
-          return {} unless Dbwatcher.configuration.system_info_include_performance_metrics
+          return {} unless Dbwatcher.configuration.system_info_include_performance_metrics?
 
           gems = {}
           Gem.loaded_specs.each do |name, spec|
@@ -154,7 +154,7 @@ module Dbwatcher
         def collect_load_path_info
           {
             size: $LOAD_PATH.size,
-            paths: Dbwatcher.configuration.system_info_include_performance_metrics ? $LOAD_PATH.first(10) : []
+            paths: Dbwatcher.configuration.system_info_include_performance_metrics? ? $LOAD_PATH.first(10) : []
           }
         rescue StandardError => e
           log_error "Failed to get load path info: #{e.message}"
@@ -166,7 +166,7 @@ module Dbwatcher
         # @return [Hash] filtered environment variables
         # rubocop:disable Metrics/MethodLength
         def collect_environment_variables
-          return {} unless Dbwatcher.configuration.collect_sensitive_env_vars
+          return {} unless Dbwatcher.configuration.collect_sensitive_env_vars?
 
           env_vars = {}
 
@@ -280,14 +280,14 @@ module Dbwatcher
                 300
               end,
             collect_sensitive_env_vars:
-              if config.respond_to?(:collect_sensitive_env_vars)
-                config.collect_sensitive_env_vars
+              if config.respond_to?(:collect_sensitive_env_vars?)
+                config.collect_sensitive_env_vars?
               else
                 false
               end,
             system_info_include_performance_metrics:
-              if config.respond_to?(:system_info_include_performance_metrics)
-                config.system_info_include_performance_metrics
+              if config.respond_to?(:system_info_include_performance_metrics?)
+                config.system_info_include_performance_metrics?
               else
                 true
               end

data/lib/dbwatcher/services/system_info/system_info_collector.rb

@@ -77,7 +77,7 @@ module Dbwatcher
         #
         # @return [Hash] machine information or empty hash on error
         def collect_machine_info
-          return {} unless Dbwatcher.configuration.collect_system_info
+          return {} unless Dbwatcher.configuration.system_info
 
           MachineInfoCollector.call
         rescue StandardError => e
@@ -89,7 +89,7 @@ module Dbwatcher
         #
         # @return [Hash] database information or empty hash on error
         def collect_database_info
-          return {} unless Dbwatcher.configuration.collect_system_info
+          return {} unless Dbwatcher.configuration.system_info
 
           DatabaseInfoCollector.call
         rescue StandardError => e
@@ -101,7 +101,7 @@ module Dbwatcher
         #
         # @return [Hash] runtime information or empty hash on error
         def collect_runtime_info
-          return {} unless Dbwatcher.configuration.collect_system_info
+          return {} unless Dbwatcher.configuration.system_info
 
           RuntimeInfoCollector.call
         rescue StandardError => e

data/lib/dbwatcher/services/timeline_data_service/entry_builder.rb

@@ -66,7 +66,29 @@ module Dbwatcher
         # @param change [Hash] change data
         # @return [String, nil] record ID if available
         def extract_record_id(change)
-          change[:record_id] || change[:id] || change.dig(:changes, :id)
+          change[:record_id] || change[:id] || extract_id_from_changes(change[:changes])
+        end
+
+        # Extract ID from changes data (hash or array format)
+        #
+        # @param changes [Hash, Array, nil] changes data
+        # @return [String, nil] extracted ID
+        def extract_id_from_changes(changes)
+          return nil unless changes
+
+          case changes
+          when Hash then changes[:id]
+          when Array then extract_id_from_array_changes(changes)
+          end
+        end
+
+        # Extract ID from array of column changes
+        #
+        # @param changes [Array] array of column changes
+        # @return [String, nil] extracted ID value
+        def extract_id_from_array_changes(changes)
+          id_change = changes.find { |c| c.is_a?(Hash) && c[:column] == "id" }
+          id_change&.dig(:new_value) || id_change&.dig(:old_value)
         end
 
         # Format changes for timeline display