magic_query 0.1.1

data/lib/magic_query/rails/generators/install_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module MagicQuery
+  module Rails
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        source_root File.expand_path('templates', __dir__)
+
+        desc 'Installs Magic Query configuration files'
+
+        def create_initializer
+          template 'initializer.rb', 'config/initializers/magic_query.rb'
+        end
+
+        def create_rules_file
+          template 'magic_query.yml', 'config/magic_query.yml'
+        end
+
+        def add_routes
+          route "mount MagicQuery::Rails::Engine => '/magic_query'"
+        end
+      end
+    end
+  end
+end

data/lib/magic_query/rails/generators/templates/initializer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+MagicQuery.configure do |config|
+  # AI Provider configuration
+  # Options: :openai, :claude, :gemini
+  config.provider = :openai
+
+  # API Key for the selected provider
+  config.api_key = ENV.fetch('MAGIC_QUERY_API_KEY', nil)
+
+  # Model to use (optional, will use default for provider if not set)
+  # config.model = 'gpt-4o-mini'
+
+  # Schema configuration
+  # Option 1: Load automatically from Rails db/schema.rb (default if schema_path is not set)
+  # The schema will be automatically loaded from db/schema.rb file
+  # config.schema_path = nil  # Leave nil to use automatic Rails schema loading
+
+  # Option 2: Load from file (SQL or YAML)
+  # config.schema_path = Rails.root.join('config', 'schema.sql').to_s
+
+  # Option 3: Load from database URL (requires database-specific implementation)
+  # config.database_url = ENV['DATABASE_URL']
+
+  # Rules configuration
+  config.rules_path = Rails.root.join('config', 'magic_query.yml').to_s
+
+  # AI generation parameters
+  config.temperature = 0.3
+  config.max_tokens = 1000
+
+  # Custom base prompt (optional)
+  # config.base_prompt = 'Your custom prompt here'
+end

data/lib/magic_query/rails/generators/templates/magic_query.yml

@@ -0,0 +1,57 @@
+# Magic Query Configuration
+# This file contains rules and conventions for your database
+
+# Naming conventions
+naming_conventions:
+  table_prefix: ''
+  table_suffix: ''
+  column_naming: 'snake_case'
+
+# Relationships between tables
+relationships:
+  - 'users has_many posts'
+  - 'posts belongs_to users'
+  - 'posts has_many comments'
+  - 'comments belongs_to posts'
+
+# Business rules
+business_rules:
+  - 'Active users have status = "active"'
+  - 'Deleted records have deleted_at IS NOT NULL'
+  - 'Use soft deletes where applicable'
+
+# Table-specific rules
+tables:
+  users:
+    description: 'User accounts table'
+    important_columns:
+      - 'id (primary key)'
+      - 'email (unique, required)'
+      - 'status (active/inactive)'
+  
+  posts:
+    description: 'Blog posts table'
+    important_columns:
+      - 'id (primary key)'
+      - 'user_id (foreign key to users)'
+      - 'published_at (timestamp)'
+
+# Column-specific rules
+columns:
+  email:
+    validation: 'Must be valid email format'
+  
+  status:
+    allowed_values: ['active', 'inactive', 'pending']
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/magic_query/rails/routes.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MagicQuery
+  module Rails
+    module Routes
+      def self.draw(router)
+        router.post 'magic_query/generate', to: 'magic_query#generate', as: :magic_query_generate
+      end
+    end
+  end
+end

data/lib/magic_query/rails.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined?(Rails)
+  require_relative 'rails/engine'
+  require_relative 'rails/controller'
+  require_relative 'rails/routes'
+end

data/lib/magic_query/schema/base_loader.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'validator'
+
+module MagicQuery
+  module Schema
+    class BaseLoader
+      def initialize(config)
+        @config = config
+      end
+
+      def load
+        schema = load_schema
+        validate_schema(schema)
+        schema
+      end
+
+      protected
+
+      def load_schema
+        raise NotImplementedError, 'Subclasses must implement load_schema'
+      end
+
+      def validate_schema(schema)
+        errors = Validator.validate(schema)
+        raise Error, "Invalid schema: #{errors.join(', ')}" unless errors.empty?
+      end
+    end
+  end
+end

data/lib/magic_query/schema/database_loader.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'base_loader'
+
+module MagicQuery
+  module Schema
+    class DatabaseLoader < BaseLoader
+      def initialize(config, database_url)
+        super(config)
+        @database_url = database_url
+      end
+
+      def self.can_load?(database_url)
+        !database_url.nil? && !database_url.empty?
+      end
+
+      protected
+
+      def load_schema
+        # For generic SQL, we'll try to extract schema using a simple approach
+        # In a real implementation, you might want to use database-specific adapters
+        raise Error, 'Automatic schema extraction requires database-specific implementation'
+      end
+    end
+  end
+end

data/lib/magic_query/schema/file_loader.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'base_loader'
+require_relative 'parser'
+
+module MagicQuery
+  module Schema
+    class FileLoader < BaseLoader
+      def initialize(config, path)
+        super(config)
+        @path = path
+      end
+
+      def self.can_load?(path)
+        path && File.exist?(path)
+      end
+
+      protected
+
+      def load_schema
+        content = File.read(@path)
+        if @path.end_with?('.yml', '.yaml')
+          load_yaml_schema(content)
+        else
+          Parser.parse(content)
+        end
+      end
+
+      private
+
+      def load_yaml_schema(content)
+        yaml_data = YAML.safe_load(content)
+        schema = {}
+        yaml_data.each do |table_name, table_info|
+          schema[table_name.to_s] = {
+            columns: table_info['columns'] || [],
+            constraints: table_info['constraints'] || []
+          }
+        end
+        schema
+      end
+    end
+  end
+end

data/lib/magic_query/schema/loader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'base_loader'
+require_relative 'file_loader'
+require_relative 'rails_schema_loader'
+require_relative 'database_loader'
+
+module MagicQuery
+  module Schema
+    class Loader
+      def self.load(config)
+        new(config).load
+      end
+
+      def initialize(config)
+        @config = config
+      end
+
+      def load
+        loader = find_loader
+        loader.load
+      end
+
+      private
+
+      def find_loader
+        # Priority order:
+        # 1. File loader (if schema_path is configured and exists)
+        # 2. Rails schema loader (if Rails is available and schema.rb exists)
+        # 3. Database loader (if database_url is configured)
+        # 4. Raise error if none available
+
+        return FileLoader.new(@config, @config.schema_path) if FileLoader.can_load?(@config.schema_path)
+
+        return RailsSchemaLoader.new(@config) if RailsSchemaLoader.can_load?
+
+        return DatabaseLoader.new(@config, @config.database_url) if DatabaseLoader.can_load?(@config.database_url)
+
+        raise Error, 'Either schema_path, Rails environment, or database_url must be configured'
+      end
+    end
+  end
+end

data/lib/magic_query/schema/parser.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module MagicQuery
+  module Schema
+    class Parser
+      def self.parse(sql_schema)
+        new(sql_schema).parse
+      end
+
+      def initialize(sql_schema)
+        @sql_schema = sql_schema.to_s
+      end
+
+      def parse
+        tables = {}
+        current_table = nil
+
+        @sql_schema.lines.each do |line|
+          line = line.strip
+          next if skip_line?(line)
+
+          current_table = process_line(line, tables, current_table)
+        end
+
+        tables
+      end
+
+      def skip_line?(line)
+        line.empty? || line.start_with?('--')
+      end
+
+      def process_line(line, tables, current_table)
+        return handle_create_table(line, tables) if create_table?(line)
+        return handle_column(line, tables, current_table) if current_table && column_definition?(line)
+        return handle_constraint(line, tables, current_table) if current_table && constraint?(line)
+        return nil if end_of_table?(line)
+
+        current_table
+      end
+
+      def handle_create_table(line, tables)
+        extract_table_name(line).tap do |table_name|
+          tables[table_name] = { columns: [], constraints: [] }
+        end
+      end
+
+      def handle_column(line, tables, current_table)
+        add_column(line, tables, current_table)
+        current_table
+      end
+
+      def handle_constraint(line, tables, current_table)
+        add_constraint(line, tables, current_table)
+        current_table
+      end
+
+      def create_table?(line)
+        line.match?(/CREATE\s+TABLE/i)
+      end
+
+      def column_definition?(line)
+        line.match?(/^\w+/)
+      end
+
+      def constraint?(line)
+        line.match?(/(PRIMARY KEY|FOREIGN KEY|UNIQUE|INDEX)/i)
+      end
+
+      def end_of_table?(line)
+        line.match?(/\);?$/)
+      end
+
+      def add_column(line, tables, current_table)
+        column_info = parse_column(line)
+        tables[current_table][:columns] << column_info if column_info
+      end
+
+      def add_constraint(line, tables, current_table)
+        tables[current_table][:constraints] << line
+      end
+
+      private
+
+      def extract_table_name(line)
+        match = line.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`|")?(\w+)(?:`|")?/i)
+        match ? match[1] : nil
+      end
+
+      def parse_column(line)
+        # Simple column parser - extracts name and type
+        match = line.match(/^(\w+)\s+(\w+(?:\([^)]+\))?)/i)
+        return nil unless match
+
+        {
+          name: match[1],
+          type: match[2],
+          definition: line
+        }
+      end
+    end
+  end
+end

data/lib/magic_query/schema/rails_schema_loader.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require_relative 'base_loader'
+
+module MagicQuery
+  module Schema
+    class RailsSchemaLoader < BaseLoader
+      def self.can_load?
+        return false unless defined?(Rails)
+
+        schema_path = Rails.root.join('db', 'schema.rb')
+        File.exist?(schema_path)
+      rescue StandardError
+        false
+      end
+
+      protected
+
+      def load_schema
+        schema_path = Rails.root.join('db', 'schema.rb')
+        raise Error, "Rails schema file not found at #{schema_path}" unless File.exist?(schema_path)
+
+        content = File.read(schema_path)
+        parse_rails_schema(content)
+      end
+
+      private
+
+      def parse_rails_schema(content)
+        schema = {}
+        state = { current_table: nil, table_columns: [], table_constraints: [] }
+
+        content.lines.each do |line|
+          line = line.strip
+          next if skip_schema_line?(line)
+
+          process_schema_line(line, schema, state)
+        end
+
+        save_current_table(schema, state) if state[:current_table] && !state[:table_columns].empty?
+        filter_system_tables(schema)
+      end
+
+      def skip_schema_line?(line)
+        line.empty? || line.start_with?('#') || line.start_with?('ActiveRecord::Schema')
+      end
+
+      def process_schema_line(line, schema, state)
+        return process_create_table(line, schema, state) if create_table_line?(line)
+        return process_column(line, state) if state[:current_table] && column_line?(line)
+        return process_add_index(line, schema, state) if add_index_line?(line)
+        return process_add_foreign_key(line, schema, state) if add_foreign_key_line?(line)
+
+        save_and_reset_table(schema, state) if end_of_table_line?(line, state)
+      end
+
+      def create_table_line?(line)
+        line.match?(/create_table\s+["'](\w+)["']/)
+      end
+
+      def column_line?(line)
+        line.match?(/^t\.(\w+)\s+["'](\w+)["']/)
+      end
+
+      def add_index_line?(line)
+        line.match?(/add_index\s+["'](\w+)["']/)
+      end
+
+      def add_foreign_key_line?(line)
+        line.match?(/add_foreign_key\s+["'](\w+)["']/)
+      end
+
+      def end_of_table_line?(line, state)
+        line == 'end' && state[:current_table]
+      end
+
+      def process_create_table(line, schema, state)
+        save_current_table(schema, state) if state[:current_table]
+
+        match = line.match(/create_table\s+["'](\w+)["']/)
+        state[:current_table] = match[1]
+        state[:table_columns] = []
+        state[:table_constraints] = []
+
+        state[:table_constraints] << 'FORCE: cascade' if line.match?(/force:\s*:cascade/)
+      end
+
+      def process_column(line, state)
+        match = line.match(/^t\.(\w+)\s+["'](\w+)["']/)
+        column_type = match[1]
+        column_name = match[2]
+
+        column_def = build_column_definition(line, column_name, column_type)
+        state[:table_columns] << column_def
+      end
+
+      def build_column_definition(line, column_name, column_type)
+        null_option = line.match(/null:\s*(true|false)/)
+        default_option = line.match(/default:\s*([^,}]+)/)
+        limit_option = line.match(/limit:\s*(\d+)/)
+
+        sql_type = map_rails_type_to_sql(column_type, limit_option&.[](1))
+        definition = build_column_definition_string(column_name, sql_type, null_option, default_option)
+
+        {
+          name: column_name,
+          type: sql_type,
+          definition: definition
+        }
+      end
+
+      def build_column_definition_string(column_name, sql_type, null_option, default_option)
+        definition = "#{column_name} #{sql_type}"
+        definition += ' NOT NULL' if null_option && null_option[1] == 'false'
+        definition += " DEFAULT #{extract_default_value(default_option&.[](1))}" if default_option
+        definition
+      end
+
+      def process_add_index(line, schema, state)
+        match = line.match(/add_index\s+["'](\w+)["']/)
+        table_name = match[1]
+        columns_match = line.match(/\[([^\]]+)\]/)
+
+        return unless columns_match
+
+        constraint = build_index_constraint(line, table_name, columns_match)
+        add_constraint_to_table(schema, state, table_name, constraint)
+      end
+
+      def build_index_constraint(line, table_name, columns_match)
+        columns = columns_match[1].split(',').map(&:strip).map { |c| c.gsub(/["']/, '') }
+        name_match = line.match(/name:\s*["']([^"']+)["']/)
+        unique_match = line.match(/unique:\s*(true)/)
+
+        index_name = name_match ? name_match[1] : "index_#{table_name}_on_#{columns.join('_and_')}"
+        constraint = unique_match ? "UNIQUE INDEX #{index_name}" : "INDEX #{index_name}"
+        "#{constraint} (#{columns.join(', ')})"
+      end
+
+      def process_add_foreign_key(line, schema, state)
+        match = line.match(/add_foreign_key\s+["'](\w+)["'],\s*["'](\w+)["']/)
+        return unless match
+
+        from_table = match[1]
+        to_table = match[2]
+        column = extract_foreign_key_column(line, to_table)
+
+        constraint = "FOREIGN KEY (#{column}) REFERENCES #{to_table}(id)"
+        add_constraint_to_table(schema, state, from_table, constraint)
+      end
+
+      def extract_foreign_key_column(line, to_table)
+        column_match = line.match(/column:\s*["'](\w+)["']/)
+        return column_match[1] if column_match
+
+        to_table.end_with?('s') ? "#{to_table[0..-2]}_id" : "#{to_table}_id"
+      end
+
+      def add_constraint_to_table(schema, state, table_name, constraint)
+        if schema[table_name]
+          schema[table_name][:constraints] << constraint
+        elsif table_name == state[:current_table]
+          state[:table_constraints] << constraint
+        end
+      end
+
+      def save_and_reset_table(schema, state)
+        save_current_table(schema, state)
+        state[:current_table] = nil
+        state[:table_columns] = []
+        state[:table_constraints] = []
+      end
+
+      def save_current_table(schema, state)
+        return unless state[:current_table]
+
+        schema[state[:current_table]] = {
+          columns: state[:table_columns],
+          constraints: state[:table_constraints]
+        }
+      end
+
+      def filter_system_tables(schema)
+        schema.reject! { |k, _| %w[schema_migrations ar_internal_metadata].include?(k) }
+        schema
+      end
+
+      def map_rails_type_to_sql(rails_type, limit = nil)
+        type_map = build_type_map(limit)
+        type_map[rails_type] || rails_type.upcase
+      end
+
+      def build_type_map(limit)
+        base_types.merge('string' => string_type(limit))
+      end
+
+      def base_types
+        numeric_types.merge(text_types).merge(date_types).merge(other_types)
+      end
+
+      def numeric_types
+        {
+          'integer' => 'INTEGER',
+          'bigint' => 'BIGINT',
+          'float' => 'FLOAT',
+          'decimal' => 'DECIMAL'
+        }
+      end
+
+      def text_types
+        {
+          'text' => 'TEXT',
+          'binary' => 'BLOB'
+        }
+      end
+
+      def date_types
+        {
+          'datetime' => 'DATETIME',
+          'timestamp' => 'TIMESTAMP',
+          'time' => 'TIME',
+          'date' => 'DATE'
+        }
+      end
+
+      def other_types
+        {
+          'boolean' => 'BOOLEAN',
+          'json' => 'JSON',
+          'jsonb' => 'JSONB'
+        }
+      end
+
+      def string_type(limit)
+        limit ? "VARCHAR(#{limit})" : 'VARCHAR(255)'
+      end
+
+      def extract_default_value(default_str)
+        return 'NULL' if default_str.nil?
+
+        default_str = default_str.strip
+        # Remove quotes if present
+        default_str = default_str.gsub(/^["']|["']$/, '')
+        # Check if it's a number
+        return default_str if default_str.match?(/^\d+$/)
+        # Check if it's a boolean
+        return default_str if %w[true false].include?(default_str)
+
+        # Otherwise return as string
+        "'#{default_str}'"
+      end
+    end
+  end
+end

data/lib/magic_query/schema/validator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module MagicQuery
+  module Schema
+    class Validator
+      def self.validate(schema)
+        new(schema).validate
+      end
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def validate
+        errors = []
+
+        unless @schema.is_a?(Hash)
+          errors << 'Schema must be a Hash'
+          return errors
+        end
+
+        @schema.each do |table_name, table_info|
+          errors.concat(validate_table(table_name, table_info))
+        end
+
+        errors
+      end
+
+      def validate_table(table_name, table_info)
+        errors = []
+        unless table_info.is_a?(Hash)
+          errors << "Table #{table_name}: must be a Hash"
+          return errors
+        end
+
+        errors << "Table #{table_name}: columns must be an Array" unless table_info[:columns].is_a?(Array)
+        errors
+      end
+
+      def valid?
+        validate.empty?
+      end
+    end
+  end
+end

data/lib/magic_query/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MagicQuery
+  VERSION = '0.1.1'
+end