better_structure_sql 0.1.0

data/lib/better_structure_sql/generators/trigger_generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Generators
+    # Generates CREATE TRIGGER statements
+    #
+    # Supports BEFORE, AFTER, INSTEAD OF triggers with row/statement timing.
+    class TriggerGenerator < Base
+      # Generates CREATE TRIGGER statement
+      #
+      # @param trigger [Hash] Trigger metadata
+      # @return [String] SQL statement
+      def generate(trigger)
+        # PostgreSQL's pg_get_triggerdef returns complete CREATE TRIGGER statement
+        # MySQL SHOW CREATE TRIGGER also returns complete statement
+        if trigger[:definition]
+          definition = trigger[:definition].strip
+
+          # Strip DEFINER clause for MySQL triggers for portability
+          definition = definition.gsub(/CREATE DEFINER=`[^`]+`@`[^`]+`/, 'CREATE') if definition.include?('CREATE DEFINER')
+
+          # Ensure ends with semicolon for structure.sql
+          definition += ';' unless definition.end_with?(';')
+          return definition
+        end
+
+        # For MySQL/SQLite, generate CREATE TRIGGER from components
+        timing = trigger[:timing] || 'AFTER'
+        event = trigger[:event] || 'INSERT'
+        table_name = quote_identifier(trigger[:table_name])
+        trigger_name = quote_identifier(trigger[:name])
+        statement = trigger[:statement] || trigger[:body] || ''
+
+        <<~SQL.strip
+          CREATE TRIGGER #{trigger_name}
+          #{timing} #{event} ON #{table_name}
+          FOR EACH ROW
+          BEGIN
+            #{statement}
+          END;
+        SQL
+      end
+
+      private
+
+      def quote_identifier(identifier)
+        return identifier if identifier.nil?
+
+        # Use double quotes for SQL standard identifier quoting
+        "\"#{identifier}\""
+      end
+    end
+  end
+end

data/lib/better_structure_sql/generators/type_generator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Generators
+    # Generates CREATE TYPE statements for enums and composite types
+    class TypeGenerator < Base
+      # Generates CREATE TYPE statement
+      #
+      # @param type [Hash] Type metadata (enum or composite)
+      # @return [String, nil] SQL statement or nil if unsupported
+      def generate(type)
+        case type[:type]
+        when 'enum'
+          generate_enum(type)
+        when 'composite'
+          generate_composite(type)
+        when 'domain'
+          generate_domain(type)
+        else
+          # Unknown type, skip
+          nil
+        end
+      end
+
+      private
+
+      def generate_enum(type)
+        values = type[:values].map { |v| "'#{v}'" }.join(', ')
+        "CREATE TYPE IF NOT EXISTS #{type[:name]} AS ENUM (#{values});"
+      end
+
+      def generate_composite(type)
+        # Composite types have attributes
+        attrs = type[:attributes].map do |attr|
+          "#{attr[:name]} #{attr[:type]}"
+        end.join(', ')
+        "CREATE TYPE IF NOT EXISTS #{type[:name]} AS (#{attrs});"
+      end
+
+      def generate_domain(type)
+        parts = ["CREATE DOMAIN IF NOT EXISTS #{type[:name]} AS #{type[:base_type]}"]
+        parts << type[:constraint] if type[:constraint]
+        "#{parts.join(' ')};"
+      end
+    end
+  end
+end

data/lib/better_structure_sql/generators/view_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Generators
+    # Generates CREATE VIEW statements
+    class ViewGenerator < Base
+      # Generates CREATE VIEW statement
+      #
+      # @param view [Hash] View metadata with definition
+      # @return [String] SQL statement
+      def generate(view)
+        # Only add schema prefix for non-default schemas
+        # PostgreSQL default: 'public'
+        # SQLite default: 'main'
+        # MySQL default: current database
+        default_schemas = %w[public main]
+        schema_prefix = default_schemas.include?(view[:schema]) ? '' : "#{view[:schema]}."
+        definition = view[:definition].strip
+
+        # Ensure definition ends with semicolon
+        definition += ';' unless definition.end_with?(';')
+
+        "CREATE OR REPLACE VIEW #{schema_prefix}#{view[:name]} AS\n#{definition}"
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/extensions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for database extensions
+    module Extensions
+      # Fetches database extensions
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of extension metadata hashes
+      def fetch_extensions(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_extensions(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch extensions: #{e.message}"
+        []
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/foreign_keys.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for foreign key constraints
+    module ForeignKeys
+      # Fetches foreign key constraints
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of foreign key metadata hashes
+      def fetch_foreign_keys(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_foreign_keys(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch foreign keys: #{e.message}"
+        []
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/functions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for database functions
+    module Functions
+      # Fetches database functions and stored procedures
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of function metadata hashes
+      def fetch_functions(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_functions(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch functions: #{e.message}"
+        []
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/indexes.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for database indexes
+    module Indexes
+      # Fetches database indexes
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of index metadata hashes
+      def fetch_indexes(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_indexes(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch indexes: #{e.message}"
+        []
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/sequences.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for database sequences
+    module Sequences
+      # Fetches database sequences
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of sequence metadata hashes
+      def fetch_sequences(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_sequences(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch sequences: #{e.message}"
+        []
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/tables.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for database tables
+    module Tables
+      # Fetches database tables
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of table metadata hashes
+      def fetch_tables(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_tables(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch tables: #{e.message}"
+        []
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/triggers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for database triggers
+    module Triggers
+      # Fetches database triggers
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of trigger metadata hashes
+      def fetch_triggers(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_triggers(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch triggers: #{e.message}"
+        []
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/types.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for custom database types
+    module Types
+      # Fetches custom database types (enums, domains, composite)
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of type metadata hashes
+      def fetch_custom_types(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_custom_types(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch custom types: #{e.message}"
+        []
+      end
+
+      # Fetches enum types only
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of enum type metadata hashes
+      def fetch_enums(connection)
+        fetch_custom_types(connection).select { |t| t[:type] == 'enum' }
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection/views.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  module Introspection
+    # Introspection module for database views
+    module Views
+      # Fetches database views
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of view metadata hashes
+      def fetch_views(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_views(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch views: #{e.message}"
+        []
+      end
+
+      # Fetches materialized views
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [Array<Hash>] Array of materialized view metadata hashes
+      def fetch_materialized_views(connection)
+        adapter = get_adapter(connection)
+        adapter.fetch_materialized_views(connection)
+      rescue StandardError => e
+        warn "Warning: Failed to fetch materialized views: #{e.message}"
+        []
+      end
+
+      private
+
+      def get_adapter(connection)
+        @get_adapter ||= Adapters::Registry.adapter_for(
+          connection,
+          adapter_override: BetterStructureSql.configuration.adapter
+        )
+      end
+    end
+  end
+end

data/lib/better_structure_sql/introspection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'introspection/extensions'
+require_relative 'introspection/sequences'
+require_relative 'introspection/types'
+require_relative 'introspection/tables'
+require_relative 'introspection/indexes'
+require_relative 'introspection/foreign_keys'
+require_relative 'introspection/views'
+require_relative 'introspection/functions'
+require_relative 'introspection/triggers'
+
+module BetterStructureSql
+  # Introspection facade for database metadata extraction
+  #
+  # Provides a unified interface for querying database objects across
+  # all supported adapters (PostgreSQL, MySQL, SQLite).
+  module Introspection
+    class << self
+      include Extensions
+      include Sequences
+      include Types
+      include Tables
+      include Indexes
+      include ForeignKeys
+      include Views
+      include Functions
+      include Triggers
+    end
+  end
+end

data/lib/better_structure_sql/manifest_generator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module BetterStructureSql
+  # Generates manifest JSON files for multi-file schema dumps
+  # Provides statistics and metadata about the schema files
+  class ManifestGenerator
+    attr_reader :config
+
+    def initialize(config = BetterStructureSql.configuration)
+      @config = config
+    end
+
+    # Generate JSON manifest from file map
+    # @param file_map [Hash] Map of relative_path => content
+    # @return [String] JSON manifest string
+    def generate(file_map)
+      manifest = {
+        version: '1.0',
+        total_files: file_map.size,
+        total_lines: calculate_total_lines(file_map),
+        max_lines_per_file: config.max_lines_per_file,
+        directories: calculate_directory_stats(file_map)
+      }
+
+      JSON.pretty_generate(manifest)
+    end
+
+    # Parse manifest JSON string
+    # @param json_string [String] The JSON manifest
+    # @return [Hash] Parsed manifest data
+    def parse(json_string)
+      JSON.parse(json_string, symbolize_names: true)
+    end
+
+    private
+
+    # Calculate total lines across all files
+    # @param file_map [Hash] Map of relative_path => content
+    # @return [Integer] Total line count
+    def calculate_total_lines(file_map)
+      file_map.values.sum { |content| content.lines.count }
+    end
+
+    # Calculate statistics per directory
+    # @param file_map [Hash] Map of relative_path => content
+    # @return [Hash] Directory name => {files:, lines:}
+    def calculate_directory_stats(file_map)
+      stats = Hash.new { |h, k| h[k] = { files: 0, lines: 0 } }
+
+      file_map.each do |path, content|
+        # Extract directory name (e.g., "1_extensions" from "1_extensions/000001.sql")
+        directory = path.split('/').first
+        next unless directory
+
+        stats[directory][:files] += 1
+        stats[directory][:lines] += content.lines.count
+      end
+
+      # Sort by directory name to ensure consistent ordering
+      stats.sort.to_h
+    end
+  end
+end