QueryWise 0.2.0

data/app/controllers/api/v1/analysis_controller.rb

@@ -0,0 +1,340 @@
+class Api::V1::AnalysisController < Api::V1::BaseController
+  def analyze
+    if params[:queries].nil?
+      render_error('Missing required parameter: queries')
+      return
+    end
+
+    queries_data = params[:queries]
+
+    # Validate queries using the validator
+    validation_errors = QueryDataValidator.validate_queries(queries_data)
+    if validation_errors.any?
+      render_error('Validation failed', :bad_request, errors: validation_errors)
+      return
+    end
+    
+    # Create QueryAnalysis records
+    query_analyses = []
+    queries_data.each do |query_data|
+      begin
+        analysis = create_query_analysis(query_data)
+        query_analyses << analysis if analysis
+      rescue => e
+        Rails.logger.error "Error creating query analysis: #{e.message}"
+        Rails.logger.error e.backtrace.join("\n")
+      end
+    end
+
+    if query_analyses.empty?
+      render_error('No valid queries provided')
+      return
+    end
+
+    # Run analysis
+    begin
+      analysis_results = perform_analysis(query_analyses)
+    rescue => e
+      Rails.logger.error "Error performing analysis: #{e.message}"
+      Rails.logger.error e.backtrace.join("\n")
+      render_error('Analysis failed')
+      return
+    end
+    
+    # Store optimization suggestions
+    begin
+      store_suggestions(query_analyses, analysis_results)
+    rescue => e
+      Rails.logger.error "Failed to store suggestions: #{e.message}"
+      Rails.logger.error e.backtrace.join("\n")
+      # Continue without storing suggestions for now
+    end
+    
+    # Format response
+    response_data = format_analysis_response(analysis_results)
+    
+    render_success(response_data, message: "Analyzed #{query_analyses.length} queries")
+  end
+  
+  def analyze_ci
+    if params[:queries].nil?
+      render_error('Missing required parameter: queries')
+      return
+    end
+
+    queries_data = params[:queries]
+    threshold_score = params[:threshold_score] || 70
+
+    # Validate queries using the validator
+    validation_errors = QueryDataValidator.validate_queries(queries_data)
+    if validation_errors.any?
+      render_error('Validation failed', :bad_request, errors: validation_errors)
+      return
+    end
+
+    # Validate threshold score
+    if threshold_score.present? && (!threshold_score.is_a?(Numeric) || threshold_score < 0 || threshold_score > 100)
+      render_error('Threshold score must be a number between 0 and 100')
+      return
+    end
+    
+    # Create temporary QueryAnalysis records (don't persist for CI)
+    query_analyses = []
+    queries_data.each do |query_data|
+      analysis = build_query_analysis(query_data)
+      query_analyses << analysis if analysis&.valid?
+    end
+    
+    if query_analyses.empty?
+      render_error('No valid queries provided')
+      return
+    end
+    
+    # Run analysis
+    analysis_results = perform_analysis(query_analyses)
+    
+    # Calculate CI score
+    ci_results = calculate_ci_score(analysis_results, threshold_score)
+    
+    render_success(ci_results)
+  end
+  
+  private
+  
+  def create_query_analysis(query_data)
+    sql_query = query_data[:sql] || query_data['sql']
+    duration_ms = query_data[:duration_ms] || query_data['duration_ms']
+
+    if sql_query.blank?
+      return nil
+    end
+
+    parser = SqlParserService.new(sql_query)
+
+    # Ensure we have valid parsed data
+    unless parser.valid?
+      Rails.logger.error "Invalid SQL query: #{sql_query}"
+      return nil
+    end
+
+    @current_app_profile.query_analyses.create!(
+      sql_query: sql_query,
+      duration_ms: duration_ms,
+      table_name: parser.primary_table,
+      query_type: parser.query_type,
+      analyzed_at: Time.current,
+      query_hash: parser.query_signature,
+      parsed_data: {
+        where_columns: parser.where_columns,
+        order_by_columns: parser.order_by_columns,
+        all_tables: parser.all_tables
+      }
+    )
+  rescue => e
+    Rails.logger.error "Failed to create query analysis: #{e.message}"
+    Rails.logger.error e.backtrace.join("\n")
+    nil
+  end
+  
+  def build_query_analysis(query_data)
+    sql_query = query_data[:sql] || query_data['sql']
+    duration_ms = query_data[:duration_ms] || query_data['duration_ms']
+    
+    return nil if sql_query.blank?
+    
+    parser = SqlParserService.new(sql_query)
+    
+    @current_app_profile.query_analyses.build(
+      sql_query: sql_query,
+      duration_ms: duration_ms,
+      table_name: parser.primary_table,
+      query_type: parser.query_type,
+      analyzed_at: Time.current,
+      query_hash: parser.query_signature,
+      parsed_data: {
+        where_columns: parser.where_columns,
+        order_by_columns: parser.order_by_columns,
+        all_tables: parser.all_tables
+      }
+    )
+  rescue => e
+    Rails.logger.error "Failed to build query analysis: #{e.message}"
+    nil
+  end
+  
+  def perform_analysis(query_analyses)
+    results = {
+      n_plus_one: [],
+      slow_queries: [],
+      missing_indexes: []
+    }
+    
+    # N+1 Detection
+    n_plus_one_patterns = NPlusOneDetectorService.detect(query_analyses)
+    results[:n_plus_one] = n_plus_one_patterns
+    
+    # Slow Query Analysis
+    slow_query_issues = SlowQueryAnalyzerService.analyze(query_analyses)
+    results[:slow_queries] = slow_query_issues
+    
+    # Missing Index Detection
+    index_suggestions = MissingIndexDetectorService.detect(query_analyses)
+    results[:missing_indexes] = index_suggestions
+    
+    results
+  end
+  
+  def store_suggestions(query_analyses, analysis_results)
+    # Store N+1 suggestions
+    analysis_results[:n_plus_one].each do |pattern|
+      next unless pattern[:first_query]
+      
+      OptimizationSuggestion.create!(
+        query_analysis: pattern[:first_query],
+        suggestion_type: 'n_plus_one',
+        title: pattern[:suggestion][:title],
+        description: pattern[:suggestion][:description],
+        sql_suggestion: pattern[:suggestion][:sql_suggestion],
+        priority: severity_to_priority(pattern[:severity]),
+        metadata: pattern.except(:first_query, :sample_queries)
+      )
+    end
+    
+    # Store slow query suggestions
+    analysis_results[:slow_queries].each do |issue|
+      issue[:suggestions].each do |suggestion|
+        OptimizationSuggestion.create!(
+          query_analysis: issue[:query_analysis],
+          suggestion_type: 'slow_query',
+          title: suggestion[:title],
+          description: suggestion[:description],
+          sql_suggestion: suggestion[:sql_example],
+          priority: priority_to_number(suggestion[:priority]),
+          metadata: suggestion.except(:title, :description, :sql_example)
+        )
+      end
+    end
+    
+    # Store index suggestions (create a representative query analysis if needed)
+    analysis_results[:missing_indexes].each do |suggestion|
+      # Find a representative query for this table
+      representative_query = query_analyses.find { |qa| qa.table_name == suggestion[:table_name] }
+      next unless representative_query
+      
+      OptimizationSuggestion.create!(
+        query_analysis: representative_query,
+        suggestion_type: 'missing_index',
+        title: "Add index on #{suggestion[:table_name]}(#{suggestion[:columns].join(', ')})",
+        description: suggestion[:description],
+        sql_suggestion: suggestion[:sql],
+        priority: suggestion[:priority],
+        metadata: suggestion.except(:sql, :description)
+      )
+    end
+  rescue => e
+    Rails.logger.error "Failed to store suggestions: #{e.message}"
+  end
+  
+  def format_analysis_response(results)
+    {
+      n_plus_one: {
+        detected: results[:n_plus_one].any?,
+        patterns: results[:n_plus_one].map { |pattern| format_n_plus_one_pattern(pattern) }
+      },
+      slow_queries: results[:slow_queries].map { |issue| format_slow_query_issue(issue) },
+      missing_indexes: results[:missing_indexes].map { |suggestion| format_index_suggestion(suggestion) },
+      summary: {
+        total_issues: results[:n_plus_one].length + results[:slow_queries].length,
+        index_suggestions: results[:missing_indexes].length,
+        severity_breakdown: calculate_severity_breakdown(results)
+      }
+    }
+  end
+  
+  def format_n_plus_one_pattern(pattern)
+    {
+      table: pattern[:table_name],
+      column: pattern[:column_name],
+      query_count: pattern[:query_count],
+      severity: pattern[:severity],
+      suggestion: pattern[:suggestion][:rails_suggestion],
+      example_code: pattern[:suggestion][:example_code]
+    }
+  end
+  
+  def format_slow_query_issue(issue)
+    {
+      sql: issue[:query_analysis].sql_query,
+      duration_ms: issue[:duration_ms],
+      severity: issue[:severity],
+      table: issue[:table_name],
+      suggestions: issue[:suggestions].map { |s| s.slice(:title, :description, :recommendation) }
+    }
+  end
+  
+  def format_index_suggestion(suggestion)
+    {
+      table: suggestion[:table_name],
+      columns: suggestion[:columns],
+      type: suggestion[:type],
+      reason: suggestion[:reason],
+      sql: suggestion[:sql],
+      priority: suggestion[:priority],
+      impact: suggestion[:impact]
+    }
+  end
+  
+  def calculate_ci_score(results, threshold)
+    total_issues = results[:n_plus_one].length + results[:slow_queries].length
+    critical_issues = results[:n_plus_one].count { |p| p[:severity] == 'critical' } +
+                     results[:slow_queries].count { |i| i[:severity] == 'critical' }
+    
+    # Calculate score (100 = perfect, 0 = terrible)
+    score = 100
+    score -= total_issues * 5  # -5 points per issue
+    score -= critical_issues * 15  # Additional -15 points for critical issues
+    score = [score, 0].max  # Don't go below 0
+    
+    {
+      score: score,
+      passed: score >= threshold,
+      threshold: threshold,
+      issues: {
+        total: total_issues,
+        critical: critical_issues,
+        n_plus_one: results[:n_plus_one].length,
+        slow_queries: results[:slow_queries].length
+      },
+      recommendations: results[:missing_indexes].length
+    }
+  end
+  
+  def severity_to_priority(severity)
+    case severity
+    when 'low' then 1
+    when 'medium' then 2
+    when 'high' then 3
+    when 'critical' then 4
+    else 2
+    end
+  end
+  
+  def priority_to_number(priority)
+    case priority
+    when 'low' then 1
+    when 'medium' then 2
+    when 'high' then 3
+    when 'critical' then 4
+    else 2
+    end
+  end
+  
+  def calculate_severity_breakdown(results)
+    breakdown = { low: 0, medium: 0, high: 0, critical: 0 }
+    
+    results[:n_plus_one].each { |p| breakdown[p[:severity].to_sym] += 1 }
+    results[:slow_queries].each { |i| breakdown[i[:severity].to_sym] += 1 }
+    
+    breakdown
+  end
+end

data/app/controllers/api/v1/api_keys_controller.rb

@@ -0,0 +1,83 @@
+class Api::V1::ApiKeysController < Api::V1::BaseController
+  skip_before_action :authenticate_api_key, only: [:create]
+  
+  def create
+    if params[:app_name].nil?
+      render_error('Missing required parameter: app_name')
+      return
+    end
+
+    app_name = params[:app_name]
+
+    if app_name.blank?
+      render_error('App name is required')
+      return
+    end
+    
+    if app_name.length < 3 || app_name.length > 100
+      render_error('App name must be between 3 and 100 characters')
+      return
+    end
+    
+    # Check if app name already exists
+    if AppProfile.exists?(name: app_name)
+      render_error('App name already exists')
+      return
+    end
+    
+    app_profile = AppProfile.new(name: app_name)
+    api_key = app_profile.generate_api_key!
+    
+    if app_profile.persisted?
+      render_success({
+        app_name: app_profile.name,
+        api_key: api_key,
+        created_at: app_profile.created_at.iso8601
+      }, message: 'API key created successfully')
+    else
+      render_error('Failed to create API key', :internal_server_error)
+    end
+  rescue ActionController::ParameterMissing => e
+    render_error("Missing required parameter: #{e.param}")
+  end
+  
+  def show
+    render_success({
+      app_name: @current_app_profile.name,
+      created_at: @current_app_profile.created_at.iso8601,
+      last_used: @current_app_profile.updated_at.iso8601,
+      total_queries: @current_app_profile.query_analyses.count
+    })
+  end
+  
+  def regenerate
+    begin
+      new_api_key = @current_app_profile.generate_api_key!
+      
+      render_success({
+        app_name: @current_app_profile.name,
+        api_key: new_api_key,
+        regenerated_at: Time.current.iso8601
+      }, message: 'API key regenerated successfully')
+    rescue => e
+      Rails.logger.error "Failed to regenerate API key: #{e.message}"
+      render_error('Failed to regenerate API key', :internal_server_error)
+    end
+  end
+  
+  def destroy
+    app_name = @current_app_profile.name
+    
+    begin
+      @current_app_profile.destroy!
+      
+      render_success({
+        app_name: app_name,
+        deleted_at: Time.current.iso8601
+      }, message: 'API key deleted successfully')
+    rescue => e
+      Rails.logger.error "Failed to delete API key: #{e.message}"
+      render_error('Failed to delete API key', :internal_server_error)
+    end
+  end
+end

data/app/controllers/api/v1/base_controller.rb

@@ -0,0 +1,93 @@
+class Api::V1::BaseController < ApplicationController
+  before_action :authenticate_api_key
+  before_action :set_default_response_format
+  before_action :check_rate_limit
+  before_action :update_last_used
+
+  rescue_from StandardError, with: :handle_standard_error
+  rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found
+  rescue_from ActionController::ParameterMissing, with: :handle_parameter_missing
+  
+  private
+  
+  def authenticate_api_key
+    api_key = request.headers['X-API-Key'] || params[:api_key]
+
+    if api_key.blank?
+      render_error('API key is required', :unauthorized)
+      return
+    end
+
+    @current_app_profile = AppProfile.find_by(api_key_digest: BCrypt::Password.create(api_key))
+
+    unless @current_app_profile
+      render_error('Invalid API key', :unauthorized)
+      return
+    end
+  end
+  
+  def set_default_response_format
+    request.format = :json
+  end
+  
+  def render_success(data, status: :ok, message: nil)
+    response = {
+      success: true,
+      data: data
+    }
+    response[:message] = message if message
+    
+    render json: response, status: status
+  end
+  
+  def render_error(message, status = :bad_request, errors: nil)
+    response = {
+      success: false,
+      error: message
+    }
+    response[:errors] = errors if errors
+    
+    render json: response, status: status
+  end
+  
+  def handle_standard_error(exception)
+    Rails.logger.error "API Error: #{exception.message}"
+    Rails.logger.error exception.backtrace.join("\n")
+    
+    render_error('Internal server error', :internal_server_error)
+  end
+  
+  def handle_not_found(exception)
+    render_error('Resource not found', :not_found)
+  end
+  
+  def handle_parameter_missing(exception)
+    render_error("Missing required parameter: #{exception.param}", :bad_request)
+  end
+
+  def check_rate_limit
+    return unless @current_app_profile
+
+    # Simple rate limiting: 1000 requests per hour per API key
+    cache_key = "rate_limit:#{@current_app_profile.id}"
+    current_count = Rails.cache.read(cache_key) || 0
+
+    if current_count >= 1000
+      render_error('Rate limit exceeded. Maximum 1000 requests per hour.', :too_many_requests)
+      return
+    end
+
+    Rails.cache.write(cache_key, current_count + 1, expires_in: 1.hour)
+  end
+
+  def update_last_used
+    return unless @current_app_profile
+
+    # Update the last used timestamp (but not on every request to avoid too many DB writes)
+    last_update = Rails.cache.read("last_update:#{@current_app_profile.id}")
+    if last_update.nil? || last_update < 5.minutes.ago
+      @current_app_profile.touch(:updated_at)
+      Rails.cache.write("last_update:#{@current_app_profile.id}", Time.current, expires_in: 5.minutes)
+    end
+  end
+end

data/app/controllers/api/v1/health_controller.rb

@@ -0,0 +1,86 @@
+class Api::V1::HealthController < Api::V1::BaseController
+  # Skip authentication for health checks
+  skip_before_action :authenticate_api_key
+  
+  def show
+    health_data = {
+      status: 'ok',
+      timestamp: Time.current.iso8601,
+      version: '1.0.0',
+      services: check_services
+    }
+    
+    overall_status = health_data[:services].values.all? { |status| status == 'ok' } ? 'ok' : 'degraded'
+    health_data[:status] = overall_status
+    
+    status_code = overall_status == 'ok' ? :ok : :service_unavailable
+    
+    render json: health_data, status: status_code
+  end
+  
+  private
+  
+  def check_services
+    services = {}
+    
+    # Database connectivity
+    services[:database] = check_database
+    
+    # SQL Parser
+    services[:sql_parser] = check_sql_parser
+    
+    # Analysis services
+    services[:analysis_services] = check_analysis_services
+    
+    services
+  end
+  
+  def check_database
+    ActiveRecord::Base.connection.execute('SELECT 1')
+    'ok'
+  rescue => e
+    Rails.logger.error "Database health check failed: #{e.message}"
+    'error'
+  end
+  
+  def check_sql_parser
+    test_sql = "SELECT id FROM users WHERE email = 'test@example.com'"
+    parser = SqlParserService.new(test_sql)
+    
+    if parser.valid? && parser.query_type == 'SELECT' && parser.primary_table == 'users'
+      'ok'
+    else
+      'error'
+    end
+  rescue => e
+    Rails.logger.error "SQL Parser health check failed: #{e.message}"
+    'error'
+  end
+  
+  def check_analysis_services
+    # Test with a simple query analysis
+    test_queries = [
+      QueryAnalysis.new(
+        sql_query: "SELECT * FROM users WHERE id = 1",
+        duration_ms: 100,
+        table_name: "users",
+        query_type: "SELECT",
+        analyzed_at: Time.current
+      )
+    ]
+    
+    # Test N+1 detector
+    NPlusOneDetectorService.detect(test_queries)
+    
+    # Test slow query analyzer
+    SlowQueryAnalyzerService.analyze(test_queries)
+    
+    # Test missing index detector
+    MissingIndexDetectorService.detect(test_queries)
+    
+    'ok'
+  rescue => e
+    Rails.logger.error "Analysis services health check failed: #{e.message}"
+    'error'
+  end
+end

data/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::API
+end

data/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end

data/app/models/app_profile.rb

@@ -0,0 +1,18 @@
+class AppProfile < ApplicationRecord
+  has_many :query_analyses, dependent: :destroy
+  has_many :optimization_suggestions, through: :query_analyses
+
+  validates :name, presence: true, length: { minimum: 1, maximum: 100 }
+  validates :api_key_digest, presence: true, uniqueness: true
+
+  def self.authenticate_with_api_key(api_key)
+    find_by(api_key_digest: BCrypt::Password.create(api_key))
+  end
+
+  def generate_api_key!
+    api_key = SecureRandom.hex(32)
+    self.api_key_digest = BCrypt::Password.create(api_key)
+    save!
+    api_key
+  end
+end

data/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end

data/app/models/optimization_suggestion.rb

@@ -0,0 +1,44 @@
+class OptimizationSuggestion < ApplicationRecord
+  belongs_to :query_analysis
+  has_one :app_profile, through: :query_analysis
+
+  validates :suggestion_type, presence: true,
+            inclusion: { in: %w[n_plus_one slow_query missing_index query_optimization] }
+  validates :title, presence: true, length: { maximum: 200 }
+  validates :description, presence: true
+  validates :priority, presence: true,
+            inclusion: { in: 1..4 }  # 1=low, 2=medium, 3=high, 4=critical
+
+  scope :by_type, ->(type) { where(suggestion_type: type) }
+  scope :by_priority, ->(priority) { where(priority: priority) }
+  scope :high_priority, -> { where(priority: [3, 4]) }
+  scope :not_implemented, -> { where(implemented: false) }
+  scope :implemented, -> { where(implemented: true) }
+
+  def priority_label
+    case priority
+    when 1 then 'Low'
+    when 2 then 'Medium'
+    when 3 then 'High'
+    when 4 then 'Critical'
+    end
+  end
+
+  def mark_implemented!
+    update!(implemented: true)
+  end
+
+  def self.create_for_analysis(analysis, suggestions_data)
+    suggestions_data.map do |suggestion_data|
+      create!(
+        query_analysis: analysis,
+        suggestion_type: suggestion_data[:type],
+        title: suggestion_data[:title],
+        description: suggestion_data[:description],
+        sql_suggestion: suggestion_data[:sql_suggestion],
+        priority: suggestion_data[:priority] || 2,
+        metadata: suggestion_data[:metadata] || {}
+      )
+    end
+  end
+end