dbwatcher 1.0.0 → 1.1.1

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramData
+      # Attribute representing a property of an entity
+      #
+      # This class provides a standardized representation for entity attributes
+      # (columns, fields, properties) with consistent validation and serialization.
+      #
+      # @example
+      #   attribute = Attribute.new(
+      #     name: "email",
+      #     type: "string",
+      #     nullable: false,
+      #     default: nil,
+      #     metadata: { unique: true }
+      #   )
+      #   attribute.valid? # => true
+      #   attribute.to_h   # => { name: "email", type: "string", ... }
+      class Attribute
+        attr_accessor :name, :type, :nullable, :default, :metadata
+
+        # Initialize attribute
+        #
+        # @param name [String] attribute name
+        # @param type [String] attribute data type
+        # @param nullable [Boolean] whether attribute can be null
+        # @param default [Object] default value
+        # @param metadata [Hash] additional type-specific information
+        def initialize(name:, type: nil, nullable: true, default: nil, metadata: {})
+          @name = name.to_s
+          @type = type.to_s
+          @nullable = nullable == true
+          @default = default
+          @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?
+        end
+
+        # Get validation errors
+        #
+        # @return [Array<String>] array of validation error messages
+        def validation_errors
+          errors = []
+          errors << "Name cannot be blank" if name.nil? || name.to_s.strip.empty?
+          errors << "Metadata must be a Hash" unless metadata.is_a?(Hash)
+          errors
+        end
+
+        # Check if attribute is a primary key
+        #
+        # @return [Boolean] true if attribute is a primary key
+        def primary_key?
+          metadata[:primary_key] == true
+        end
+
+        # Check if attribute is a foreign key
+        #
+        # @return [Boolean] true if attribute is a foreign key
+        def foreign_key?
+          metadata[:foreign_key] == true || name.to_s.end_with?("_id")
+        end
+
+        # Serialize attribute to hash
+        #
+        # @return [Hash] serialized attribute data
+        def to_h
+          {
+            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
+  end
+end

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

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramData
+      # Complete dataset for diagram generation
+      #
+      # This class serves as a container for all diagram data including entities
+      # and relationships, with validation and management capabilities.
+      #
+      # @example
+      #   dataset = Dataset.new
+      #   dataset.add_entity(Entity.new(id: "users", name: "User", type: "table"))
+      #   dataset.add_entity(Entity.new(id: "orders", name: "Order", type: "table"))
+      #   dataset.add_relationship(Relationship.new(
+      #     source_id: "users", target_id: "orders", type: "has_many"
+      #   ))
+      #   dataset.valid? # => true
+      #   dataset.to_h   # => complete dataset hash
+      class Dataset
+        attr_reader :entities, :relationships, :metadata
+
+        # Initialize empty dataset
+        #
+        # @param metadata [Hash] optional dataset-level metadata
+        def initialize(metadata: {})
+          @entities = {}
+          @relationships = []
+          @metadata = metadata.is_a?(Hash) ? metadata : {}
+        end
+
+        # Add entity to dataset
+        #
+        # @param entity [Entity] entity to add
+        # @return [Entity] the added entity
+        # @raise [ArgumentError] if entity is invalid
+        def add_entity(entity)
+          raise ArgumentError, "Entity must be an Entity instance" unless entity.is_a?(Entity)
+
+          raise ArgumentError, "Entity is invalid: #{entity.validation_errors.join(", ")}" unless entity.valid?
+
+          @entities[entity.id] = entity
+          entity
+        end
+
+        # Add relationship to dataset
+        #
+        # @param relationship [Relationship] relationship to add
+        # @return [Relationship] the added relationship
+        # @raise [ArgumentError] if relationship is invalid
+        def add_relationship(relationship)
+          raise ArgumentError, "Relationship must be a Relationship instance" unless relationship.is_a?(Relationship)
+
+          unless relationship.valid?
+            raise ArgumentError, "Relationship is invalid: #{relationship.validation_errors.join(", ")}"
+          end
+
+          @relationships << relationship
+          relationship
+        end
+
+        # Get entity by ID
+        #
+        # @param id [String] entity ID
+        # @return [Entity, nil] entity or nil if not found
+        def get_entity(id)
+          @entities[id.to_s]
+        end
+
+        # Check if entity exists
+        #
+        # @param id [String] entity ID
+        # @return [Boolean] true if entity exists
+        def entity?(id)
+          @entities.key?(id.to_s)
+        end
+
+        # Remove entity by ID
+        #
+        # @param id [String] entity ID
+        # @return [Entity, nil] removed entity or nil if not found
+        def remove_entity(id)
+          entity = @entities.delete(id.to_s)
+
+          # Remove relationships involving this entity
+          if entity
+            @relationships.reject! do |rel|
+              rel.source_id == id.to_s || rel.target_id == id.to_s
+            end
+          end
+
+          entity
+        end
+
+        # Remove relationship
+        #
+        # @param relationship [Relationship] relationship to remove
+        # @return [Boolean] true if relationship was removed
+        # rubocop:disable Naming/PredicateMethod
+        def remove_relationship(relationship)
+          !@relationships.delete(relationship).nil?
+        end
+        # rubocop:enable Naming/PredicateMethod
+
+        # Get relationships for an entity
+        #
+        # @param entity_id [String] entity ID
+        # @param direction [Symbol] :outgoing, :incoming, or :all
+        # @return [Array<Relationship>] filtered relationships
+        def relationships_for(entity_id, direction: :all)
+          id = entity_id.to_s
+
+          case direction
+          when :outgoing
+            @relationships.select { |rel| rel.source_id == id }
+          when :incoming
+            @relationships.select { |rel| rel.target_id == id }
+          when :all
+            @relationships.select { |rel| rel.source_id == id || rel.target_id == id }
+          else
+            raise ArgumentError, "Direction must be :outgoing, :incoming, or :all"
+          end
+        end
+
+        # Check if dataset is valid
+        #
+        # @return [Boolean] true if dataset is valid
+        def valid?
+          validation_errors.empty?
+        end
+
+        # Get validation errors
+        #
+        # @return [Array<String>] array of validation error messages
+        def validation_errors
+          errors = []
+
+          # Validate all entities
+          @entities.each do |id, entity|
+            errors << "Entity #{id} is invalid: #{entity.validation_errors.join(", ")}" unless entity.valid?
+          end
+
+          # Validate all relationships
+          @relationships.each_with_index do |relationship, index|
+            unless relationship.valid?
+              errors << "Relationship #{index} is invalid: #{relationship.validation_errors.join(", ")}"
+            end
+
+            # Check that referenced entities exist
+            unless entity?(relationship.source_id)
+              errors << "Relationship #{index} references non-existent source entity: #{relationship.source_id}"
+            end
+
+            unless entity?(relationship.target_id)
+              errors << "Relationship #{index} references non-existent target entity: #{relationship.target_id}"
+            end
+          end
+
+          # Validate metadata
+          errors << "Metadata must be a Hash" unless @metadata.is_a?(Hash)
+
+          errors
+        end
+
+        # Get dataset statistics
+        #
+        # @return [Hash] statistics about the dataset
+        def stats
+          {
+            entity_count: @entities.size,
+            relationship_count: @relationships.size,
+            entity_types: @entities.values.map(&:type).uniq.sort,
+            relationship_types: @relationships.map(&:type).uniq.sort,
+            isolated_entities: isolated_entities.map(&:id),
+            connected_entities: connected_entities.map(&:id)
+          }
+        end
+
+        # Get entities with no relationships
+        #
+        # @return [Array<Entity>] isolated entities
+        def isolated_entities
+          connected_ids = (@relationships.map(&:source_id) + @relationships.map(&:target_id)).uniq
+          @entities.values.reject { |entity| connected_ids.include?(entity.id) }
+        end
+
+        # Get entities with at least one relationship
+        #
+        # @return [Array<Entity>] connected entities
+        def connected_entities
+          connected_ids = (@relationships.map(&:source_id) + @relationships.map(&:target_id)).uniq
+          @entities.values.select { |entity| connected_ids.include?(entity.id) }
+        end
+
+        # Check if dataset is empty
+        #
+        # @return [Boolean] true if no entities or relationships
+        def empty?
+          @entities.empty? && @relationships.empty?
+        end
+
+        # Clear all data from dataset
+        #
+        # @return [self] for method chaining
+        def clear
+          @entities.clear
+          @relationships.clear
+          @metadata.clear
+          self
+        end
+
+        # Serialize dataset to hash
+        #
+        # @return [Hash] serialized dataset
+        def to_h
+          {
+            entities: @entities.transform_values(&:to_h),
+            relationships: @relationships.map(&:to_h),
+            metadata: @metadata,
+            stats: stats
+          }
+        end
+
+        # Serialize dataset to JSON
+        #
+        # @return [String] JSON representation
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+
+        # Create dataset from hash
+        #
+        # @param hash [Hash] dataset data
+        # @return [Dataset] new dataset instance
+        def self.from_h(hash)
+          dataset = new(metadata: hash[:metadata] || hash["metadata"] || {})
+
+          # Load entities
+          entities_data = hash[:entities] || hash["entities"] || {}
+          entities_data.each_value do |entity_data|
+            entity = Entity.from_h(entity_data)
+            dataset.add_entity(entity)
+          end
+
+          # Load relationships
+          relationships_data = hash[:relationships] || hash["relationships"] || []
+          relationships_data.each do |relationship_data|
+            relationship = Relationship.from_h(relationship_data)
+            dataset.add_relationship(relationship)
+          end
+
+          dataset
+        end
+
+        # Create dataset from JSON
+        #
+        # @param json [String] JSON string
+        # @return [Dataset] new dataset instance
+        def self.from_json(json)
+          from_h(JSON.parse(json))
+        end
+
+        # String representation of dataset
+        #
+        # @return [String] string representation
+        def to_s
+          "#{self.class.name}(entities: #{@entities.size}, relationships: #{@relationships.size})"
+        end
+
+        # Detailed string representation
+        #
+        # @return [String] detailed string representation
+        def inspect
+          "#{self.class.name}(entities: #{@entities.size}, relationships: #{@relationships.size}, " \
+            "metadata: #{@metadata.inspect})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramData
+      # Entity representing a node in any diagram
+      #
+      # This class provides a standardized representation for all diagram entities
+      # (nodes, tables, models, etc.) with consistent validation and serialization.
+      #
+      # @example
+      #   entity = Entity.new(
+      #     id: "users",
+      #     name: "User",
+      #     type: "table",
+      #     attributes: [
+      #       Attribute.new(name: "id", type: "integer", nullable: false, metadata: { primary_key: true })
+      #     ],
+      #     metadata: { columns: ["id", "name", "email"] }
+      #   )
+      #   entity.valid? # => true
+      #   entity.to_h   # => { id: "users", name: "User", ... }
+      class Entity
+        attr_accessor :id, :name, :type, :attributes, :metadata
+
+        # Initialize entity
+        #
+        # @param id [String] unique identifier for the entity
+        # @param name [String] display name for the entity
+        # @param type [String] entity type (table, model, etc.)
+        # @param attributes [Array<Attribute>] entity attributes/properties
+        # @param metadata [Hash] additional type-specific information
+        def initialize(id:, name:, type: "default", attributes: [], metadata: {})
+          @id = id.to_s
+          @name = name.to_s
+          @type = type.to_s
+          @attributes = attributes.is_a?(Array) ? attributes : []
+          @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?
+        end
+
+        # Get validation errors
+        #
+        # @return [Array<String>] array of validation error messages
+        def validation_errors
+          errors = []
+          errors << "ID cannot be blank" if id.nil? || id.to_s.strip.empty?
+          errors << "Name cannot be blank" if name.nil? || name.to_s.strip.empty?
+          errors << "Type cannot be blank" if type.nil? || type.to_s.strip.empty?
+          errors << "Attributes must be an Array" unless attributes.is_a?(Array)
+          errors << "Metadata must be a Hash" unless metadata.is_a?(Hash)
+
+          # Validate all attributes
+          attributes.each_with_index do |attribute, index|
+            errors << "Attribute at index #{index} is invalid" unless attribute.is_a?(Attribute) && attribute.valid?
+          end
+
+          errors
+        end
+
+        # Add an attribute to the entity
+        #
+        # @param attribute [Attribute] attribute to add
+        # @return [Attribute] the added attribute
+        # @raise [ArgumentError] if attribute is invalid
+        def add_attribute(attribute)
+          raise ArgumentError, "Attribute must be an Attribute instance" unless attribute.is_a?(Attribute)
+          raise ArgumentError, "Attribute is invalid: #{attribute.validation_errors.join(", ")}" unless attribute.valid?
+
+          @attributes << attribute
+          attribute
+        end
+
+        # Get primary key attributes
+        #
+        # @return [Array<Attribute>] primary key attributes
+        def primary_key_attributes
+          attributes.select(&:primary_key?)
+        end
+
+        # Get foreign key attributes
+        #
+        # @return [Array<Attribute>] foreign key attributes
+        def foreign_key_attributes
+          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)
+          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
+        #
+        # @return [String] detailed string representation
+        def inspect
+          "#{self.class.name}(id: #{id.inspect}, name: #{name.inspect}, " \
+            "type: #{type.inspect}, attributes: #{attributes.length}, metadata: #{metadata.inspect})"
+        end
+      end
+    end
+  end
+end