dbwatcher 1.1.3 → 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/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