database-model-generator 0.6.1 → 0.7.0

data/lib/postgresql/model/generator.rb

@@ -0,0 +1,304 @@
+require_relative '../../database_model_generator'
+
+begin
+  require 'pg'
+rescue LoadError
+  # pg not available - PostgreSQL support will be disabled
+end
+
+module Postgresql
+  module Model
+    class Generator < DatabaseModel::Generator::Base
+      VERSION = DatabaseModel::Generator::VERSION
+
+      private
+
+      def validate_connection(connection)
+        unless defined?(PG) && connection.is_a?(PG::Connection)
+          raise ArgumentError, "Connection must be a PG::Connection object. Install 'pg' gem for PostgreSQL support."
+        end
+      end
+
+      def normalize_table_name(table)
+        table.downcase # PostgreSQL uses lowercase for table names by convention
+      end
+
+      def check_table_exists(table)
+        begin
+          sql = "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'public' AND table_name = $1"
+          result = @connection.exec_params(sql, [table.downcase])
+          row = result.first
+          result.clear
+          row && row['count'].to_i > 0
+        rescue => e
+          puts "Error checking table existence: #{e.message}"
+          false
+        end
+      end
+
+      def get_column_info
+        begin
+          sql = <<~SQL
+            SELECT
+              column_name,
+              data_type,
+              character_maximum_length,
+              numeric_precision,
+              numeric_scale,
+              is_nullable,
+              column_default,
+              udt_name
+            FROM information_schema.columns
+            WHERE table_schema = 'public' AND table_name = $1
+            ORDER BY ordinal_position
+          SQL
+
+          result = @connection.exec_params(sql, [@table])
+          @column_info = []
+
+          result.each do |row|
+            @column_info << PostgresqlColumnInfo.new(row)
+          end
+
+          result.clear
+        rescue => e
+          raise "Error retrieving column information: #{e.message}"
+        end
+      end
+
+      def get_primary_keys
+        begin
+          sql = <<~SQL
+            SELECT a.attname AS column_name
+            FROM pg_index i
+            JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+            WHERE i.indrelid = $1::regclass AND i.indisprimary
+            ORDER BY a.attnum
+          SQL
+
+          result = @connection.exec_params(sql, [@table])
+          @primary_keys = []
+
+          result.each do |row|
+            @primary_keys << row['column_name']
+          end
+
+          result.clear
+        rescue => e
+          raise "Error retrieving primary keys: #{e.message}"
+        end
+      end
+
+      def get_foreign_keys
+        begin
+          sql = <<~SQL
+            SELECT
+              kcu.column_name
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.key_column_usage kcu
+              ON tc.constraint_name = kcu.constraint_name
+              AND tc.table_schema = kcu.table_schema
+            WHERE tc.table_schema = 'public'
+              AND tc.table_name = $1
+              AND tc.constraint_type = 'FOREIGN KEY'
+          SQL
+
+          result = @connection.exec_params(sql, [@table])
+          @foreign_keys = []
+
+          result.each do |row|
+            @foreign_keys << row['column_name']
+          end
+
+          result.clear
+        rescue => e
+          raise "Error retrieving foreign keys: #{e.message}"
+        end
+      end
+
+      def get_constraints
+        begin
+          sql = <<~SQL
+            SELECT
+              tc.constraint_name,
+              tc.constraint_type,
+              kcu.column_name,
+              cc.check_clause
+            FROM information_schema.table_constraints tc
+            LEFT JOIN information_schema.key_column_usage kcu
+              ON tc.constraint_name = kcu.constraint_name
+              AND tc.table_schema = kcu.table_schema
+            LEFT JOIN information_schema.check_constraints cc
+              ON tc.constraint_name = cc.constraint_name
+              AND tc.constraint_schema = cc.constraint_schema
+            WHERE tc.table_schema = 'public'
+              AND tc.table_name = $1
+          SQL
+
+          result = @connection.exec_params(sql, [@table])
+          @constraints = []
+
+          result.each do |row|
+            @constraints << {
+              'CONSTRAINT_NAME' => row['constraint_name'],
+              'CONSTRAINT_TYPE' => row['constraint_type'],
+              'COLUMN_NAME' => row['column_name'],
+              'CHECK_CLAUSE' => row['check_clause']
+            }
+          end
+
+          result.clear
+        rescue => e
+          raise "Error retrieving constraints: #{e.message}"
+        end
+      end
+
+      def get_dependencies
+        begin
+          sql = <<~SQL
+            SELECT
+              dependent_ns.nspname AS dependent_schema,
+              dependent_view.relname AS dependent_view,
+              source_table.relname AS source_table
+            FROM pg_depend
+            JOIN pg_rewrite ON pg_depend.objid = pg_rewrite.oid
+            JOIN pg_class AS dependent_view ON pg_rewrite.ev_class = dependent_view.oid
+            JOIN pg_class AS source_table ON pg_depend.refobjid = source_table.oid
+            JOIN pg_namespace dependent_ns ON dependent_ns.oid = dependent_view.relnamespace
+            WHERE source_table.relname = $1
+              AND dependent_ns.nspname = 'public'
+              AND source_table.relname != dependent_view.relname
+          SQL
+
+          result = @connection.exec_params(sql, [@table])
+          @dependencies = []
+
+          result.each do |row|
+            @dependencies << {
+              'NAME' => row['dependent_view'],
+              'TYPE' => 'VIEW'
+            }
+          end
+
+          result.clear
+        rescue => e
+          # Dependencies query may fail on some PostgreSQL versions, continue without error
+          @dependencies = []
+        end
+      end
+
+      def format_constraint_type(constraint)
+        case constraint['CONSTRAINT_TYPE']
+        when 'PRIMARY KEY' then 'Primary Key'
+        when 'FOREIGN KEY' then 'Foreign Key'
+        when 'UNIQUE' then 'Unique'
+        when 'CHECK' then 'Check'
+        else constraint['CONSTRAINT_TYPE']
+        end
+      end
+
+      def get_constraint_column_name(constraint)
+        constraint['COLUMN_NAME']
+      end
+
+      def get_constraint_text(constraint)
+        constraint['CHECK_CLAUSE']
+      end
+
+      def is_string_type?(column)
+        column.data_type.downcase =~ /(char|varchar|character varying|text|bpchar)/
+      end
+
+      def is_date_type?(column)
+        column.data_type.downcase =~ /(date|time|timestamp)/
+      end
+
+      def is_text_type?(column)
+        column.data_type.downcase =~ /(varchar|character varying|text|char)/
+      end
+
+      def get_column_size(column)
+        column.character_maximum_length
+      end
+
+      def build_full_text_index_sql(column)
+        "CREATE INDEX idx_#{@table.downcase}_#{column.name.downcase}_text ON #{@table.downcase} USING GIN (to_tsvector('english', #{column.name.downcase}))"
+      end
+
+      def get_full_text_index_type
+        "PostgreSQL Full-Text Search (GIN Index)"
+      end
+
+      def find_fk_table(fk)
+        # PostgreSQL-specific logic for finding referenced table
+        # Try to get actual referenced table from foreign key constraints
+        begin
+          sql = <<~SQL
+            SELECT
+              ccu.table_name AS referenced_table
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.key_column_usage kcu
+              ON tc.constraint_name = kcu.constraint_name
+              AND tc.table_schema = kcu.table_schema
+            JOIN information_schema.constraint_column_usage ccu
+              ON tc.constraint_name = ccu.constraint_name
+              AND tc.table_schema = ccu.table_schema
+            WHERE tc.table_schema = 'public'
+              AND tc.table_name = $1
+              AND tc.constraint_type = 'FOREIGN KEY'
+              AND kcu.column_name = $2
+          SQL
+
+          result = @connection.exec_params(sql, [@table, fk])
+          row = result.first
+          if row && row['referenced_table']
+            result.clear
+            return row['referenced_table'].downcase
+          end
+          result.clear
+        rescue => e
+          # Fall back to naming convention if query fails
+        end
+
+        # Fallback to naming convention
+        fk.gsub(/_id$/i, '').pluralize rescue "#{fk.gsub(/_id$/i, '')}s"
+      end
+
+      def disconnect
+        @connection.close if @connection && !@connection.finished?
+      end
+    end
+
+    # PostgreSQL column info wrapper
+    class PostgresqlColumnInfo
+      attr_reader :name, :data_type, :character_maximum_length, :numeric_precision, :numeric_scale, :nullable, :column_default, :udt_name
+
+      def initialize(row)
+        @name = row['column_name']
+        @data_type = row['data_type']
+        @character_maximum_length = row['character_maximum_length']&.to_i
+        @numeric_precision = row['numeric_precision']&.to_i
+        @numeric_scale = row['numeric_scale']&.to_i
+        @nullable = row['is_nullable'] == 'YES'
+        @column_default = row['column_default']
+        @udt_name = row['udt_name'] # PostgreSQL-specific user-defined type name
+      end
+
+      def nullable?
+        @nullable
+      end
+
+      def data_size
+        @character_maximum_length
+      end
+
+      def precision
+        @numeric_precision
+      end
+
+      def scale
+        @numeric_scale
+      end
+    end
+  end
+end

data/spec/postgresql_model_generator_spec.rb

@@ -0,0 +1,325 @@
+require 'spec_helper'
+require 'support/postgresql_connection'
+require 'postgresql/model/generator'
+
+RSpec.describe Postgresql::Model::Generator do
+  include_context 'PostgreSQL connection'
+
+  let(:generator) { described_class.new(connection) }
+
+  describe 'class information' do
+    it 'has the correct version number' do
+      expect(Postgresql::Model::Generator::VERSION).to eq('0.6.1')
+    end
+  end
+
+  describe '#initialize' do
+    it 'accepts a PG::Connection object' do
+      expect { described_class.new(connection) }.not_to raise_error
+    end
+
+    it 'sets up instance variables correctly' do
+      expect(generator.connection).to eq(connection)
+      expect(generator.constraints).to eq([])
+      expect(generator.primary_keys).to eq([])
+      expect(generator.foreign_keys).to eq([])
+      expect(generator.dependencies).to eq([])
+      expect(generator.belongs_to).to eq([])
+      expect(generator.column_info).to eq([])
+      expect(generator.table).to be_nil
+      expect(generator.model).to be_nil
+    end
+
+    it 'raises an error if connection is nil' do
+      expect { described_class.new(nil) }.to raise_error(ArgumentError, /Connection cannot be nil/)
+    end
+
+    it 'raises an error if connection is not a PG::Connection' do
+      expect { described_class.new("not a connection") }.to raise_error(ArgumentError, /must be a PG::Connection/)
+    end
+  end
+
+  describe '#generate' do
+    it 'responds to the generate method' do
+      expect(generator).to respond_to(:generate)
+    end
+
+    it 'works with a table name' do
+      expect { generator.generate('users') }.not_to raise_error
+    end
+
+    it 'raises an error for nil table name' do
+      expect { generator.generate(nil) }.to raise_error(ArgumentError, /Table name cannot be nil/)
+    end
+
+    it 'raises an error for empty table name' do
+      expect { generator.generate('') }.to raise_error(ArgumentError, /Table name cannot be nil/)
+    end
+
+    context 'when generating from the users table' do
+      before { generator.generate('users') }
+
+      it 'sets the table name in lowercase' do
+        expect(generator.table).to eq('users')
+      end
+
+      it 'generates a model name from the table name' do
+        expect(generator.model).to eq('User')
+      end
+
+      it 'sets view to false' do
+        expect(generator.view).to be false
+      end
+
+      it 'populates column information' do
+        expect(generator.column_info).to be_an(Array)
+        expect(generator.column_info).not_to be_empty
+
+        column_names = generator.column_info.map(&:name)
+        expect(column_names).to include('id')
+        expect(column_names).to include('username')
+        expect(column_names).to include('email')
+        expect(column_names).to include('status')
+        expect(column_names).to include('role')
+      end
+
+      it 'finds primary keys' do
+        expect(generator.primary_keys).to be_an(Array)
+        expect(generator.primary_keys).to include('id')
+      end
+
+      it 'populates constraints information' do
+        expect(generator.constraints).to be_an(Array)
+        expect(generator.constraints).not_to be_empty
+      end
+
+      it 'detects enum columns' do
+        expect(generator.has_enum_columns?).to be true
+        enum_column_names = generator.enum_column_names
+        expect(enum_column_names).to include('status')
+        expect(enum_column_names).to include('role')
+      end
+
+      it 'extracts enum values from constraints' do
+        generator.generate('users')
+        status_enum = generator.enum_columns.find { |e| e[:name] == 'status' }
+        expect(status_enum).not_to be_nil
+        expect(status_enum[:values]).to include('active', 'inactive', 'suspended', 'deleted')
+      end
+    end
+
+    context 'when generating from the posts table' do
+      before { generator.generate('posts') }
+
+      it 'sets the table name in lowercase' do
+        expect(generator.table).to eq('posts')
+      end
+
+      it 'generates the correct model name' do
+        expect(generator.model).to eq('Post')
+      end
+
+      it 'finds foreign keys' do
+        expect(generator.foreign_keys).to be_an(Array)
+        expect(generator.foreign_keys).to include('user_id')
+      end
+
+      it 'identifies belongs_to associations' do
+        expect(generator.belongs_to).to be_an(Array)
+        expect(generator.belongs_to).to include('users')
+      end
+
+      it 'detects multiple enum columns' do
+        enum_column_names = generator.enum_column_names
+        expect(enum_column_names).to include('status')
+        expect(enum_column_names).to include('priority')
+      end
+
+      it 'extracts enum values for status' do
+        status_enum = generator.enum_columns.find { |e| e[:name] == 'status' }
+        expect(status_enum).not_to be_nil
+        expect(status_enum[:values]).to include('draft', 'published', 'archived')
+      end
+
+      it 'extracts enum values for priority' do
+        priority_enum = generator.enum_columns.find { |e| e[:name] == 'priority' }
+        expect(priority_enum).not_to be_nil
+        expect(priority_enum[:values]).to include('low', 'medium', 'high', 'urgent')
+      end
+    end
+
+    context 'when generating from the comments table' do
+      before { generator.generate('comments') }
+
+      it 'detects polymorphic associations' do
+        expect(generator.has_polymorphic_associations?).to be true
+        expect(generator.polymorphic_association_names).to include('commentable')
+      end
+
+      it 'identifies polymorphic foreign keys and types' do
+        poly_assoc = generator.polymorphic_associations.first
+        expect(poly_assoc[:foreign_key]).to eq('commentable_id')
+        expect(poly_assoc[:foreign_type]).to eq('commentable_type')
+      end
+    end
+
+    context 'when generating from the post_tags table' do
+      before { generator.generate('post_tags') }
+
+      it 'detects composite primary keys' do
+        expect(generator.primary_keys).to be_an(Array)
+        expect(generator.primary_keys.length).to be >= 2
+        expect(generator.primary_keys).to include('post_id')
+        expect(generator.primary_keys).to include('tag_id')
+      end
+
+      it 'identifies multiple foreign keys' do
+        expect(generator.foreign_keys).to include('post_id')
+        expect(generator.foreign_keys).to include('tag_id')
+      end
+    end
+  end
+
+  describe '#table_exists?' do
+    it 'returns true for existing tables' do
+      generator.generate('users')
+      expect(generator.table_exists?).to be true
+    end
+
+    it 'returns false for non-existing tables' do
+      generator.generate('nonexistent_table')
+      expect(generator.table_exists?).to be false
+    end
+  end
+
+  describe '#generated?' do
+    it 'returns false before generate is called' do
+      expect(generator.generated?).to be false
+    end
+
+    it 'returns true after successful generation' do
+      generator.generate('users')
+      expect(generator.generated?).to be true
+    end
+  end
+
+  describe '#column_names' do
+    it 'returns an array of column names' do
+      generator.generate('users')
+      column_names = generator.column_names
+      expect(column_names).to be_an(Array)
+      expect(column_names).to include('id', 'username', 'email')
+    end
+  end
+
+  describe '#constraint_summary' do
+    it 'returns a hash of constraints by column' do
+      generator.generate('users')
+      summary = generator.constraint_summary
+      expect(summary).to be_a(Hash)
+    end
+  end
+
+  describe '#index_recommendations' do
+    it 'returns index recommendations' do
+      generator.generate('posts')
+      recommendations = generator.index_recommendations
+
+      expect(recommendations).to be_a(Hash)
+      expect(recommendations).to have_key(:foreign_keys)
+      expect(recommendations).to have_key(:date_queries)
+      expect(recommendations).to have_key(:status_enum)
+      expect(recommendations).to have_key(:composite)
+      expect(recommendations).to have_key(:full_text)
+    end
+
+    it 'recommends indexes for foreign keys' do
+      generator.generate('posts')
+      recommendations = generator.index_recommendations
+
+      fk_recommendations = recommendations[:foreign_keys]
+      expect(fk_recommendations).not_to be_empty
+
+      user_id_index = fk_recommendations.find { |r| r[:column] == 'user_id' }
+      expect(user_id_index).not_to be_nil
+    end
+
+    it 'recommends indexes for date columns' do
+      generator.generate('posts')
+      recommendations = generator.index_recommendations
+
+      date_recommendations = recommendations[:date_queries]
+      created_at_index = date_recommendations.find { |r| r[:column] == 'created_at' }
+      expect(created_at_index).not_to be_nil if date_recommendations.any?
+    end
+
+    it 'recommends full-text indexes for text columns' do
+      generator.generate('posts')
+      recommendations = generator.index_recommendations
+
+      fulltext_recommendations = recommendations[:full_text]
+      expect(fulltext_recommendations).to be_an(Array)
+    end
+  end
+
+  describe '#enum_definitions' do
+    it 'generates Rails enum definitions' do
+      generator.generate('users')
+      definitions = generator.enum_definitions
+
+      expect(definitions).to be_an(Array)
+      expect(definitions).not_to be_empty
+
+      # Check that definitions are in the correct format
+      definitions.each do |definition|
+        expect(definition).to match(/^enum \w+: \{.+\}$/)
+      end
+    end
+  end
+
+  describe '#polymorphic_has_many_suggestions' do
+    it 'suggests has_many associations for polymorphic parents' do
+      generator.generate('comments')
+      suggestions = generator.polymorphic_has_many_suggestions
+
+      expect(suggestions).to be_an(Array)
+      expect(suggestions).not_to be_empty if generator.has_polymorphic_associations?
+    end
+  end
+
+  describe '#model' do
+    it 'returns the active record model name' do
+      generator.generate('users')
+      expect(generator.model).to eq('User')
+    end
+
+    it 'removes trailing s from model names' do
+      generator.generate('posts')
+      expect(generator.model).to eq('Post')
+    end
+
+    it 'handles underscored table names' do
+      generator.generate('post_tags')
+      expect(generator.model).to eq('PostTag')
+    end
+  end
+
+  describe '#disconnect' do
+    it 'closes the database connection' do
+      conn_params = {
+        host: ENV['POSTGRES_HOST'] || 'localhost',
+        port: ENV['POSTGRES_PORT'] || '5432',
+        dbname: ENV['POSTGRES_DATABASE'] || 'test_db',
+        user: ENV['POSTGRES_USER'] || 'postgres'
+      }
+      conn_params[:password] = ENV['POSTGRES_PASSWORD'] if ENV['POSTGRES_PASSWORD']
+
+      test_conn = PG.connect(conn_params)
+
+      test_gen = described_class.new(test_conn)
+      test_gen.disconnect
+
+      expect(test_conn.finished?).to be true
+    end
+  end
+end

data/spec/support/postgresql_connection.rb

@@ -0,0 +1,71 @@
+require 'pg'
+
+# Shared context for PostgreSQL database connection and test data
+RSpec.shared_context 'PostgreSQL connection' do
+  before(:context) do
+    @pg_connection = begin
+      # In Docker environment, use the service name instead of localhost
+      host = ENV['POSTGRES_HOST'] || 'localhost'
+      port = ENV['POSTGRES_PORT'] || '5432'
+      database = ENV['POSTGRES_DATABASE'] || 'test_db'
+      user = ENV['POSTGRES_USER'] || 'postgres'
+      password = ENV['POSTGRES_PASSWORD']
+
+      conn_params = {
+        host: host,
+        port: port,
+        dbname: database,
+        user: user
+      }
+      conn_params[:password] = password if password
+
+      PG.connect(conn_params)
+    rescue PG::Error => e
+      warn "Database connection failed: #{e.message}"
+      warn "Make sure PostgreSQL database is running and accessible"
+      warn "Connection string: #{host}:#{port}/#{database}"
+      warn "User: #{user}"
+      raise e
+    end
+
+    # Ensure test data exists
+    setup_test_data
+  end
+
+  after(:context) do
+    # Cleanup test data if needed
+    cleanup_test_data
+
+    # Close the connection
+    @pg_connection&.close
+  end
+
+  # Use a method instead of let for context-level variables
+  def connection
+    @pg_connection
+  end
+
+  private
+
+  def setup_test_data
+    # The init-db.sql script should have already created the tables and data
+    # This is just a verification step
+    begin
+      result = @pg_connection.exec("SELECT COUNT(*) FROM users")
+      count = result.first['count'].to_i
+      result.clear
+
+      if count == 0
+        warn "Warning: Test data not found. Make sure init-db.sql has been run."
+      end
+    rescue PG::Error => e
+      warn "Error checking test data: #{e.message}"
+    end
+  end
+
+  def cleanup_test_data
+    # In Docker environment, we don't need to cleanup as containers are disposable
+    # In local environment, you might want to clean up test data here
+    # For now, we'll leave the data intact for debugging purposes
+  end
+end