dbwatcher 0.1.5 → 1.1.0

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "base_api"
+
+module Dbwatcher
+  module Storage
+    module Api
+      class QueryAPI < BaseAPI
+        # Filter queries by date
+        #
+        # @param date [Date, String] date to filter by
+        # @return [QueryAPI] self for method chaining
+        def for_date(date)
+          @date = date.is_a?(String) ? date : date.strftime("%Y-%m-%d")
+          self
+        end
+
+        # Filter to slow queries only
+        #
+        # @param threshold [Integer] duration threshold in milliseconds
+        # @return [QueryAPI] self for method chaining
+        def slow_only(threshold: 100)
+          filters[:slow_threshold] = threshold
+          self
+        end
+
+        # Filter queries by table name
+        #
+        # @param table_name [String] table name to filter by
+        # @return [QueryAPI] self for method chaining
+        def by_table(table_name)
+          filters[:table_name] = table_name
+          self
+        end
+
+        # Filter queries between dates
+        #
+        # @param start_date [Date, String] start date
+        # @param end_date [Date, String] end date
+        # @return [QueryAPI] self for method chaining
+        def between(start_date, end_date)
+          start_str = start_date.is_a?(String) ? start_date : start_date.strftime("%Y-%m-%d")
+          end_str = end_date.is_a?(String) ? end_date : end_date.strftime("%Y-%m-%d")
+          @date_range = Date.parse(start_str)..Date.parse(end_str)
+          self
+        end
+
+        # Get all filtered queries
+        #
+        # @return [Array<Hash>] filtered queries
+        def all
+          queries = fetch_queries
+          apply_filters(queries)
+        end
+
+        private
+
+        def fetch_queries
+          if @date_range
+            @date_range.map { |date| storage.load_for_date(date.strftime("%Y-%m-%d")) }.flatten
+          elsif @date
+            storage.load_for_date(@date)
+          else
+            recent_queries
+          end
+        end
+
+        def apply_filters(queries)
+          result = queries
+
+          # Apply slow threshold filter using symbols only
+          if filters[:slow_threshold]
+            result = result.select do |q|
+              duration = safe_extract(q, :duration)
+              duration && duration > filters[:slow_threshold]
+            end
+          end
+
+          # Apply table name filter using symbols only
+          result = result.select { |q| safe_extract(q, :table_name) == filters[:table_name] } if filters[:table_name]
+
+          # Apply common filters
+          apply_common_filters(result)
+        end
+
+        def recent_queries
+          (0..6).map do |days_ago|
+            date = (Date.today - days_ago).strftime("%Y-%m-%d")
+            storage.load_for_date(date)
+          end.flatten
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "base_api"
+require_relative "concerns/table_analyzer"
+
+module Dbwatcher
+  module Storage
+    module Api
+      class SessionAPI < BaseAPI
+        # Include table analysis capabilities for API layer
+        include Api::Concerns::TableAnalyzer
+
+        # Find a specific session by ID
+        #
+        # @param id [String] the session ID
+        # @return [Session, nil] the session object or nil if not found
+        def find(id)
+          storage.load(id)
+        end
+
+        # Get all sessions
+        #
+        # @return [Array<Hash>] array of session data
+        def all
+          apply_filters(storage.all)
+        end
+
+        # Filter to recent sessions
+        #
+        # @param days [Integer] number of days back to include
+        # @return [SessionAPI] self for method chaining
+        def recent(days: 7)
+          cutoff = Time.now - (days * 24 * 60 * 60)
+          where(started_after: cutoff)
+        end
+
+        # Filter sessions that have changes
+        #
+        # @return [SessionAPI] self for method chaining
+        def with_changes
+          filters[:has_changes] = true
+          self
+        end
+
+        # Filter sessions by status
+        #
+        # @param status [String, Symbol] session status (e.g., :active, :completed)
+        # @return [SessionAPI] self for method chaining
+        def by_status(status)
+          filters[:status] = status.to_s
+          self
+        end
+
+        # Filter sessions by name pattern
+        #
+        # @param pattern [String] name pattern to match
+        # @return [SessionAPI] self for method chaining
+        def by_name(pattern)
+          filters[:name_pattern] = pattern
+          self
+        end
+
+        # Get sessions with table analysis
+        #
+        # @return [Array<Hash>] sessions with analyzed table data
+        def with_table_analysis
+          all.map do |session_info|
+            session = find(safe_extract(session_info, :id))
+            next session_info unless session
+
+            session_info.merge(
+              tables_summary: build_tables_summary(session)
+            )
+          end.compact
+        end
+
+        # Get the most active sessions (by change count)
+        #
+        # @param limit [Integer] maximum number of sessions to return
+        # @return [Array<Hash>] sessions ordered by activity
+        def most_active(limit: 10)
+          sessions_with_counts = all.map do |session_info|
+            session = find(safe_extract(session_info, :id))
+            change_count = session ? session.changes.length : 0
+            session_info.merge(change_count: change_count)
+          end
+
+          sessions_with_counts
+            .sort_by { |s| -s[:change_count] }
+            .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)
+          sessions
+            .then { |s| filter_by_start_time(s) }
+            .then { |s| filter_by_status(s) }
+            .then { |s| filter_by_name_pattern(s) }
+            .then { |s| filter_by_changes(s) }
+            .then { |s| apply_common_filters(s) }
+        end
+
+        def filter_by_start_time(sessions)
+          return sessions unless filters[:started_after]
+
+          apply_time_filter(sessions, :started_at)
+        end
+
+        def filter_by_status(sessions)
+          return sessions unless filters[:status]
+
+          sessions.select { |s| safe_extract(s, :status) == filters[:status] }
+        end
+
+        def filter_by_name_pattern(sessions)
+          return sessions unless filters[:name_pattern]
+
+          apply_pattern_filter(sessions, %i[name id], filters[:name_pattern])
+        end
+
+        def filter_by_changes(sessions)
+          return sessions unless filters[:has_changes]
+
+          sessions.select do |s|
+            session = find(safe_extract(s, :id))
+            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
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "base_api"
+
+module Dbwatcher
+  module Storage
+    module Api
+      class TableAPI < BaseAPI
+        # Filter changes for specific table
+        #
+        # @param table_name [String] table name
+        # @return [TableAPI] self for method chaining
+        def changes_for(table_name)
+          @table_name = table_name
+          self
+        end
+
+        # Filter to recent changes
+        #
+        # @param days [Integer] number of days back
+        # @return [TableAPI] self for method chaining
+        def recent(days: 7)
+          filters[:recent_days] = days
+          self
+        end
+
+        # Filter by operation type
+        #
+        # @param operation [String, Symbol] operation type
+        # @return [TableAPI] self for method chaining
+        def by_operation(operation)
+          filters[:operation] = normalize_operation(operation)
+          self
+        end
+
+        # Get all filtered changes
+        #
+        # @return [Array<Hash>] filtered changes
+        def all
+          return [] unless @table_name
+
+          changes = storage.load_changes(@table_name)
+          apply_filters(changes)
+        end
+
+        # Get most active tables
+        #
+        # @param limit [Integer] maximum number of tables
+        # @return [Array<Hash>] most active tables
+        def most_active(limit: 10)
+          # This would require aggregating across all tables
+          # For now, return empty array - can be implemented later
+          # TODO: Implement most active tables functionality with limit parameter
+          _ = limit # Acknowledge the parameter for future use
+          []
+        end
+
+        private
+
+        def apply_filters(changes)
+          result = changes
+
+          # Apply recent filter using symbols only
+          if filters[:recent_days]
+            cutoff = Time.now - (filters[:recent_days] * 24 * 60 * 60)
+            result = result.select do |change|
+              timestamp = normalize_timestamp(safe_extract(change, :timestamp))
+              timestamp >= cutoff
+            end
+          end
+
+          # Apply operation filter using symbols only
+          if filters[:operation]
+            result = result.select do |change|
+              operation = normalize_operation(safe_extract(change, :operation))
+              operation == filters[:operation]
+            end
+          end
+
+          # Apply common filters
+          apply_common_filters(result)
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/storage/base_storage.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "file_manager"
+require_relative "errors"
+require_relative "concerns/error_handler"
+require_relative "concerns/timestampable"
+require_relative "concerns/validatable"
+
+module Dbwatcher
+  module Storage
+    # Base class for all storage implementations
+    #
+    # Provides common functionality for storage classes including
+    # file management, error handling, validation, and timestamping.
+    # Follows the Ruby style guide patterns for class organization.
+    #
+    # @abstract Subclass and implement specific storage logic
+    # @example
+    #   class MyStorage < BaseStorage
+    #     include Concerns::Validatable
+    #
+    #     validates_presence_of :id, :name
+    #
+    #     def save(data)
+    #       validate_presence!(data)
+    #       safe_write_json(file_path, data)
+    #     end
+    #   end
+    class BaseStorage
+      # Include shared concerns
+      include Concerns::ErrorHandler
+      include Concerns::Timestampable
+
+      # Configuration constants
+      DEFAULT_PERMISSIONS = 0o755
+      JSON_FILE_EXTENSION = ".json"
+
+      # @return [String] the configured storage path
+      attr_reader :storage_path
+
+      # @return [FileManager] the file manager instance
+      attr_reader :file_manager
+
+      # Initializes the base storage with configured path and file manager
+      #
+      # Sets up the storage path from configuration, creates a file manager
+      # 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
+      end
+
+      protected
+
+      # Safely writes JSON data to a file
+      #
+      # @param file_path [String] the path to write to
+      # @param data [Object] the data to serialize as JSON
+      # @return [Boolean] true if successful, false otherwise
+      def safe_write_json(file_path, data)
+        safe_operation("write JSON to #{file_path}") do
+          file_manager.write_json(file_path, data)
+          touch_updated_at
+          true
+        end
+      end
+
+      # Safely reads JSON data from a file
+      #
+      # @param file_path [String] the path to read from
+      # @param default [Object] default value if file doesn't exist or is invalid
+      # @return [Object] the parsed JSON data or default value
+      def safe_read_json(file_path, default = [])
+        safe_operation("read JSON from #{file_path}", default) do
+          file_manager.read_json(file_path)
+        end
+      end
+
+      # Removes a file safely
+      #
+      # @param file_path [String] the path to the file to remove
+      # @return [Boolean] true if file was removed, false if it didn't exist
+      def safe_delete_file(file_path)
+        safe_operation("delete file #{file_path}") do
+          file_manager.delete_file(file_path)
+        end
+      end
+
+      # Removes a directory safely
+      #
+      # @params directory_path [String] the path to the directory to remove
+      # @return [Boolean] true if directory was removed, false if it didn't exist
+      def safe_delete_directory(directory_path)
+        safe_operation("delete directory #{directory_path}") do
+          file_manager.delete_directory(directory_path)
+        end
+      end
+
+      private
+
+      # Ensures the storage directory exists with proper permissions
+      #
+      # @return [void]
+      def ensure_storage_directory
+        file_manager.ensure_directory(storage_path)
+      end
+    end
+  end
+end

data/lib/dbwatcher/storage/change_processor.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Storage
+    class ChangeProcessor
+      include Concerns::DataNormalizer
+
+      def initialize(session_storage)
+        @session_storage = session_storage
+        @session_cache = {}
+      end
+
+      def process_table_changes(table_name)
+        all_changes = collect_all_changes(table_name)
+        sort_changes_by_timestamp(all_changes)
+      end
+
+      private
+
+      def collect_all_changes(table_name)
+        changes = []
+
+        @session_storage.all.each do |session_info|
+          session_changes = extract_table_changes_from_session(session_info[:id], table_name)
+          changes.concat(session_changes)
+        end
+
+        changes
+      end
+
+      def extract_table_changes_from_session(session_id, table_name)
+        session = load_session_with_cache(session_id)
+        return [] unless session.respond_to?(:changes) && session.changes
+
+        session.changes
+               .select { |change| matches_table?(change, table_name) }
+               .map { |change| enrich_change(change, session) }
+      end
+
+      def load_session_with_cache(session_id)
+        @session_cache[session_id] ||= @session_storage.load(session_id)
+      end
+
+      def matches_table?(change, table_name)
+        extract_value(change, :table_name) == table_name
+      end
+
+      def enrich_change(change, session)
+        normalized_change = normalize_change(change)
+        add_session_context(normalized_change, session)
+      end
+
+      def add_session_context(change, session)
+        change.merge(
+          session_id: session.id,
+          session_name: session.name
+        )
+      end
+
+      def sort_changes_by_timestamp(changes)
+        changes.sort_by { |change| normalize_timestamp(extract_value(change, "timestamp")) }.reverse
+      end
+    end
+  end
+end

data/lib/dbwatcher/storage/concerns/data_normalizer.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Storage
+    module Concerns
+      # Provides consistent data normalization capabilities across storage classes
+      #
+      # This concern standardizes how different data types are normalized to ensure
+      # consistent symbol-key usage and proper data formatting throughout the storage layer.
+      #
+      # @example
+      #   class MyStorage < BaseStorage
+      #     include Concerns::DataNormalizer
+      #
+      #     def save(data)
+      #       normalized_data = normalize_session_data(data)
+      #       # ... save logic
+      #     end
+      #   end
+      module DataNormalizer
+        # Normalizes session input to hash with consistent symbol keys
+        #
+        # @param session [Hash, Object] session data to normalize
+        # @return [Hash] normalized session hash with symbol keys
+        def normalize_session_data(session)
+          case session
+          when Hash
+            normalize_hash_keys(session)
+          when ->(s) { s.respond_to?(:to_h) }
+            normalize_hash_keys(session.to_h)
+          else
+            extract_object_attributes(session)
+          end
+        end
+
+        # Normalizes hash keys to symbols (Rails-compatible)
+        #
+        # @param hash [Hash] hash to normalize
+        # @return [Hash] hash with symbolized keys
+        def normalize_hash_keys(hash)
+          return hash unless hash.is_a?(Hash)
+
+          if hash.respond_to?(:with_indifferent_access)
+            hash.with_indifferent_access.symbolize_keys
+          else
+            hash.transform_keys { |key| key.to_s.to_sym }
+          end
+        end
+
+        # Normalize change data to use consistent symbol keys
+        #
+        # @param change [Hash] change data to normalize
+        # @return [Hash] normalized change hash with symbol keys
+        def normalize_change(change)
+          return change unless change.is_a?(Hash)
+
+          normalize_hash_keys(change)
+        end
+
+        # Extract value by trying both string and symbol keys
+        #
+        # @param hash [Hash] hash to extract from
+        # @param key [String, Symbol] key to extract
+        # @return [Object] extracted value or nil
+        def extract_value(hash, key)
+          return nil unless hash.is_a?(Hash)
+
+          hash[key.to_sym] || hash[key.to_s]
+        end
+
+        # Normalize timestamp to consistent format
+        #
+        # @param timestamp [String, Time, Numeric] timestamp to normalize
+        # @return [Time] normalized timestamp
+        def normalize_timestamp(timestamp)
+          return Time.at(0) unless timestamp
+
+          case timestamp
+          when String
+            Time.parse(timestamp)
+          when Time
+            timestamp
+          when Numeric
+            Time.at(timestamp)
+          else
+            Time.at(0)
+          end
+        rescue ArgumentError, TypeError
+          Time.at(0)
+        end
+
+        # Normalize operation to uppercase string
+        #
+        # @param operation [String, Symbol] operation to normalize
+        # @return [String] uppercase operation string
+        def normalize_operation(operation)
+          operation&.to_s&.upcase
+        end
+
+        # Normalize table name to string
+        #
+        # @param table_name [String, Symbol] table name to normalize
+        # @return [String] normalized table name
+        def normalize_table_name(table_name)
+          table_name&.to_s
+        end
+
+        # Normalize record ID to string
+        #
+        # @param record_id [String, Integer] record ID to normalize
+        # @return [String] normalized record ID
+        def normalize_record_id(record_id)
+          record_id&.to_s
+        end
+
+        private
+
+        # Extracts attributes from objects that don't respond to to_h
+        #
+        # @param object [Object] object to extract attributes from
+        # @return [Hash] extracted attributes hash
+        def extract_object_attributes(object)
+          {
+            id: object.respond_to?(:id) ? object.id : nil,
+            name: object.respond_to?(:name) ? object.name : nil,
+            started_at: object.respond_to?(:started_at) ? object.started_at : nil,
+            ended_at: object.respond_to?(:ended_at) ? object.ended_at : nil,
+            changes: object.respond_to?(:changes) ? object.changes : []
+          }
+        end
+      end
+    end
+  end
+end