active_record_mysql_repl 0.1.0 → 0.1.2

data/lib/active_record_mysql_repl/database/association.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveRecordMysqlRepl
+  module Database
+    class Associations
+      class AnalyzedTable
+        attr_accessor :name, :has_many, :has_one, :belongs_to
+        def initialize(name)
+          @name = name
+          @has_many = []
+          @has_one = []
+          @belongs_to = []
+        end
+      end
+
+      def self.load(path)
+        new(YAML.load_file(path, aliases: true))
+      end
+
+      def initialize(associations)
+        @associations = associations.map { |key, association| [key, Association.new(association)] }.to_h
+      end
+
+      def [](key)
+        @associations[key]
+      end
+
+      # Analyze the relationship between tables based on the information of *_id columns
+      # For example, if users.company_id exists, users belongs_to companies and companies has_many users
+      def self.analyze(tables, association_settings)
+        analyzed_tables = tables.map { |table| [table, AnalyzedTable.new(table)] }.to_h
+
+        analyzed_tables.each do |table_name, table|
+          association_setting = association_settings[table_name]
+          columns = ActiveRecord::Base.connection.columns(table_name)
+          columns.each do |column|
+            next if association_setting.present? && association_settings.ignore_columns(table_name).include?(column.name)
+
+            associatable = column.name.gsub(/_id$/, '') if column.name.end_with?('_id')
+            next if associatable.blank? || associatable == 'class' # reserved word
+
+            if analyzed_tables.keys.include?(associatable.pluralize)
+              table.belongs_to << associatable.singularize if associatable
+              analyzed_tables[associatable.pluralize].has_many << table_name.pluralize
+            else
+              associatable_table_name = associatable.split('_').last
+              if analyzed_tables.keys.include?(associatable_table_name.pluralize)
+                table.belongs_to << { name: associatable, class_name: associatable_table_name.classify, foreign_key: :id }
+              else
+                table.belongs_to << { name: associatable, class_name: table_name.singularize.classify, foreign_key: :id }
+              end
+            end
+          end
+
+          next if association_setting.blank?
+
+          # merge yaml settings
+          [:has_many, :belongs_to].each do |type|
+            ass = association_setting.fetch(type.to_s, []).map(&:symbolize_keys)
+            table.send(type).concat(ass) unless ass.blank?
+          end
+        end
+
+        analyzed_tables.values
+      end
+    end
+
+    class Association
+      def initialize(association)
+        @association = association
+      end
+
+      def [](table)
+        table = (@association.keys - ['ignore_columns']) & [table]
+        @association[table.first] if table.present?
+      end
+
+      def ignore_columns(table)
+        @association.fetch('ignore_columns', {}).fetch(table, [])
+      end
+    end
+  end
+end

data/lib/active_record_mysql_repl/database/configs.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveRecordMysqlRepl
+  module Database
+    class Configs
+      attr_reader :configs
+
+      def self.load(path)
+        new(YAML.load_file(path))
+      end
+
+      def [](key)
+        configs[key]
+      end
+
+      def keys
+        configs.keys
+      end
+
+      private
+
+      def initialize(configs)
+        @configs = configs.map { |key, config| [key, Config.new(config)] }.to_h
+      end
+    end
+
+    private
+
+    class Config
+      attr_reader *%i[
+        bastion
+        ssh_user
+        remote_host
+        database
+        port
+        user
+        password
+        prompt_color
+      ]
+
+      def initialize(config)
+        @bastion = config["bastion"]
+        @ssh_user = config["ssh_user"]
+        @remote_host = config["remote_host"]
+        @database = config["database"]
+        @port = config["port"]
+        @user = config["user"]
+        @password = config["password"]
+        @prompt_color = config["prompt_color"]
+      end
+    end
+  end
+end

data/lib/active_record_mysql_repl/database/connection.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecordMysqlRepl
+  module Database
+    module Connection
+      MAX_RETRY = 3
+
+      def self.connect(db_config, port)
+        conn = {
+          adapter: 'mysql2',
+          host: '127.0.0.1',
+          port: port,
+          username: db_config.user,
+          password: db_config.password,
+          database: db_config.database,
+        }
+
+        ActiveRecord::Base.logger = Logger.new(STDOUT)
+        conn = ActiveRecord::Base.establish_connection(conn)
+
+        puts "Ensureing connection to #{db_config.database} on port 127.0.0.1:#{port}".gray
+
+        tables = nil
+        (1..MAX_RETRY-1).to_a.each do |time|
+          begin
+            tables = ActiveRecord::Base.connection.tables
+          rescue => e
+            puts "#{e}, Retry #{time}/#{MAX_RETRY}".red
+              sleep time*time
+            next
+          end
+        end
+
+        if tables.blank?
+          raise "Retred #{MAX_RETRY} times, but failed to connect to database."
+        end
+
+        yield if block_given?
+      end
+    end
+  end
+end

data/lib/active_record_mysql_repl/database/loader.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'active_record'
+require 'active_support/all'
+
+module ActiveRecordMysqlRepl
+  module Database
+    module Loader
+      def self.load_tables(db_config_key, army_config, port)
+        puts "Loading tables".gray
+
+        tables = ActiveRecord::Base.connection.tables
+        association_settings = Associations.load(army_config.associations)
+
+        analyzed_tables = Associations.analyze(tables, association_settings[db_config_key])
+        skipped = []
+        analyzed_tables.each do |analyzed_table|
+          # defer model definition for tables with `has_many: :xxx, through: xxx` associations
+          if analyzed_table.has_many.any? { |hm| hm.is_a?(Hash) && hm.key?(:through) }
+            skipped << analyzed_table
+            next
+          end
+          define_model(analyzed_table)
+        end
+
+        skipped.each do |analyzed_table|
+          define_model(analyzed_table)
+        end
+      end
+
+      def self.define_model(analyzed_table)
+        klass = Class.new(ActiveRecord::Base)
+
+        analyzed_table.has_many.each do |has_many|
+          if has_many.is_a?(String)
+            klass.has_many has_many.to_sym
+          elsif has_many.is_a?(Hash)
+            klass.has_many has_many[:name].to_sym, **has_many.except(:name)
+          end
+        end
+
+        analyzed_table.has_one.each do |has_one|
+          klass.has_one has_one[:name].to_sym, class_name: has_one[:class_name], foreign_key: has_one[:foreign_key]
+        end
+
+        analyzed_table.belongs_to.each do |belongs_to|
+          if belongs_to.is_a?(String)
+            klass.belongs_to belongs_to.to_sym
+          elsif belongs_to.is_a?(Hash)
+            klass.belongs_to belongs_to[:name].to_sym, class_name: belongs_to[:class_name].to_sym
+          end
+        end
+
+        # allow type column
+        klass.inheritance_column = :_type_disabled
+        klass.table_name = analyzed_table.name
+
+        Object.const_set(analyzed_table.name.classify, klass)
+      end
+    end
+  end
+end

data/lib/active_record_mysql_repl/database.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'database/configs'
+require_relative 'database/association'
+require_relative 'database/connection'
+require_relative 'database/loader'
+
+module ActiveRecordMysqlRepl
+  module Database; end
+end

data/lib/active_record_mysql_repl/extensions/active_record.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiverecordMysqlRepl
+  module Extensions
+    module ActiveRecord
+      module Base
+        def as(name = nil)
+          self.reflect_on_all_associations(name).map(&:name)
+        end
+
+        def describe
+          [
+            exec_sql("DESCRIBE #{self.table_name}").tab(:h),
+            exec_sql("SHOW INDEX FROM #{self.table_name}").tab(:h)
+          ].join("\n")
+        end
+
+        alias desc describe
+        alias d describe
+
+        def show_ddl
+          exec_sql("SHOW CREATE TABLE #{self.table_name}")[0]['Create Table']
+        end
+
+        alias ddl show_ddl
+      end
+
+      ::ActiveRecord::Base.extend(Base)
+    end
+  end
+end
+

data/lib/active_record_mysql_repl/extensions/global.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiverecordMysqlRepl
+  module Extensions
+    module Global
+      def tables
+        ::ActiveRecord::Base.connection.tables.map(&:singularize).map(&:classify)
+      end
+
+      def models
+        ::ActiveRecord::Base.subclasses
+      end
+
+      def transaction
+        ::ActiveRecord::Base.transaction { yield }
+      end
+
+      def exec_sql(sql)
+        res = ::ActiveRecord::Base.connection.select_all(sql)
+        res.rows.map do |row|
+          res.columns.zip(row).to_h
+        end
+      end
+    end
+
+    Kernel.include(Global)
+  end
+end
+

data/lib/active_record_mysql_repl/extensions/hash.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiverecordMysqlRepl
+  module Extensions
+    module Hash
+      def method_missing(name, *args)
+        if (self.keys & [name, name.to_s]).present?
+          self[name] || self[name.to_s]
+        elsif name.to_s.end_with?('=') && self.keys.include?(name.to_s[0..-2])
+          name = name[0..-2]
+          self[name] = args.first if self.key?(name)
+          self[name.to_sym] = args.first if self.key?(name.to_sym)
+        end
+      end
+
+      ::Hash.include(Hash)
+    end
+  end
+end
+

data/lib/active_record_mysql_repl/extensions/object.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'terminal-table'
+require 'csv'
+require 'clipboard'
+require 'json'
+
+module ActiverecordMysqlRepl
+  module Extensions
+    module Object
+      def tabulate(orientation = nil)
+        arr = if self.is_a?(Array)
+                self
+              elsif self.is_a?(::ActiveRecord::Relation)
+                self.to_a
+              else
+                [self]
+              end
+
+        arr = arr.map do |e|
+          if e.is_a?(::ActiveRecord::Base)
+            values =  e.attributes.transform_values do |v|
+              next JSON.pretty_generate(v) if v.is_a?(Enumerable) && v.size > 0
+              next 'NULL' if v.nil?
+              next '""' if v == ''
+              v.to_s
+            end
+            next values
+          end
+          e
+        end
+
+        raise "#{arr} is not an array of hash".red unless arr.all? { |e| e.is_a?(Hash) }
+        raise "#{arr} contains Hashes with different keys".red unless arr.map(&:keys).uniq.size == 1
+
+        orientation = case orientation
+                      when :vertical, :v
+                        :vertical
+                      when :horizontal, :h
+                        :horizontal
+                      else
+                        if arr.first.keys.size > 5
+                          :vertical
+                        else
+                          :horizontal
+                        end
+                      end
+
+        t = Terminal::Table.new
+
+        case orientation
+        when :horizontal
+          t.headings = arr.first.keys
+          t.rows = arr.map(&:values)
+
+        when :vertical
+          t.headings = ['Name', 'Value']
+          arr.each.with_index do |row, i|
+            row.each { |col, val| t.add_row [col, val] }
+            t.add_separator if i < arr.size - 1
+          end
+        end
+
+        t.to_s
+      end
+
+      alias tab tabulate
+      alias table tabulate
+      alias to_table tabulate
+
+      def csv(orientation = nil)
+        arr = if self.is_a?(Array)
+                self
+              elsif self.is_a?(ActiveRecord::Relation)
+                self.to_a
+              else
+                [self]
+              end
+
+        arr = arr.map do |e|
+          if e.is_a?(ActiveRecord::Base)
+            values =  e.attributes.transform_values do |v|
+              next JSON.pretty_generate(v) if v.is_a?(Enumerable) && v.size > 0
+              next 'NULL' if v.nil?
+              next '""' if v == ''
+              v.to_s
+            end
+            next values
+          end
+          e
+        end
+
+        raise "#{arr} is not an array of hash".red unless arr.all? { |e| e.is_a?(Hash) }
+        raise "#{arr} contains Hashes with different keys".red unless arr.map(&:keys).uniq.size == 1
+
+        orientation = case orientation
+                      when :vertical, :v
+                        :vertical
+                      when :horizontal, :h
+                        :horizontal
+                      else
+                        if arr.first.keys.size > 5
+                          :vertical
+                        else
+                          :horizontal
+                        end
+                      end
+
+        CSV.generate do |csv|
+          case orientation
+          when :horizontal
+            csv << arr.first.keys
+            arr.each { |row| csv << row.values }
+          when :vertical
+            arr.each do |row|
+              row.each { |col, val| csv << [col, val] }
+              csv << []
+            end
+          end
+        end
+      end
+
+      def copy
+        Clipboard.copy(self.to_s)
+      end
+      alias cp copy
+
+      alias j to_json
+
+      def jp
+        JSON.pretty_generate(JSON.parse(to_json))
+      end
+    end
+  end
+
+  ::Object.include(Extensions::Object)
+end
+

data/lib/active_record_mysql_repl/extensions/tabler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiverecordMysqlRepl
+  module Extensions
+    module Tabler
+      ::ActiveRecord::Base.subclasses.each do |model|
+        define_method(model.table_name) do
+          model.find(self)
+        end
+
+        define_method(model.table_name.singularize) do
+          model.find(self)
+        end
+
+        model.column_names.each do |column|
+          define_method("#{model.table_name.singularize}_by_#{column}") do
+            model.where(column => self)
+          end
+
+          define_method("#{model.table_name.singularize}_#{column}_like") do
+            model.where("#{column} like ?", "%#{self}%")
+          end
+        end
+      end
+    end
+
+    String.include Tabler
+    Symbol.include Tabler
+    Enumerable.include Tabler
+  end
+end
+

data/lib/active_record_mysql_repl/extensions.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'extensions/object'
+require_relative 'extensions/global'
+require_relative 'extensions/active_record'
+require_relative 'extensions/hash'
+require_relative 'extensions/tabler'
+
+module ActiveRecordMysqlRepl
+  module Extensions
+    def self.load_external(dir)
+      Dir.glob("#{dir}/*.rb").each do |file|
+        require file
+      end
+    end
+  end
+end
+

data/lib/active_record_mysql_repl/ssh_tunnel.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'net/ssh'
+require 'net/ssh/gateway'
+
+module ActiveRecordMysqlRepl
+  module SSHTunnel
+    EPHEMERAL_PORT = 0
+
+    def self.tunnel(db_config)
+      return yield(db_config.port) if block_given? unless db_config.bastion
+
+      puts "Establishing ssh tunnel to #{db_config.remote_host}:#{db_config.port} via #{db_config.ssh_user}#{db_config.bastion}".gray
+
+      gateway = Net::SSH::Gateway.new(db_config.bastion, db_config.ssh_user)
+      gateway.open(db_config.remote_host, db_config.port) do |port|
+        yield(port) if block_given?
+      end
+    end
+  end
+end

data/lib/active_record_mysql_repl/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRecordMysqlRepl
+  VERSION = "0.1.2"
+end

data/lib/active_record_mysql_repl.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "active_record_mysql_repl/version"
+require_relative 'active_record_mysql_repl/config'
+require_relative 'active_record_mysql_repl/cli'
+require_relative 'active_record_mysql_repl/database'
+require_relative 'active_record_mysql_repl/ssh_tunnel'
+require_relative 'active_record_mysql_repl/version'
+# extensions should be loaded after database connection is established
+# require_relative 'active_record_mysql_repl/extensions'
+
+module ActiveRecordMysqlRepl; end

data/sample_config/.army.sample.yml

@@ -0,0 +1,6 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/nogahighland/active_record_mysql_repl/refs/heads/main/json_schemas/army_schema.json
+
+database_config: ./databases.sample.yml
+associations: ./associations.sample.yml
+extensions_dir:
+pryrc: ./.pryrc.sample

data/sample_config/.pryrc.sample

@@ -0,0 +1,9 @@
+begin
+  require "awesome_print"
+  Pry.config.print = proc do |_output, value, pry_instance|
+    value = value.is_a?(String) ? value : value.ai
+    pry_instance.pager.page(value)
+  end
+rescue LoadError
+  puts "no awesome_print :("
+end

data/sample_config/associations.sample.yml

@@ -0,0 +1,13 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/nogahighland/active_record_mysql_repl/refs/heads/main/json_schemas/association_schema.json
+
+test:
+  users:
+    belongs_to:
+      - name: profile
+        foreign_key: id
+        class_name: UserProfile
+
+  ignore_columns:
+    user:
+    - login_id
+

data/sample_config/databases.sample.yml

@@ -0,0 +1,9 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/nogahighland/active_record_mysql_repl/refs/heads/main/json_schema/databases_schema.json
+
+test:
+  remote_host: 127.0.0.1
+  database: test
+  port: 3306
+  user: root
+  password: root
+  prompt_color: cyan