mimi-db 0.1.4 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 769933b1c8f1c8f8cc063866b542ad18bd3d1605
-  data.tar.gz: b84ebf567414894a5c4c60a1c9d0cb8632773def
+  metadata.gz: 3b4f245675fc0702efca73d4a00440f13b126907
+  data.tar.gz: 04e158a27a77c427e7d56e43c1425ca341254b41
 SHA512:
-  metadata.gz: f4fbec564e7394baa9ce38d24feddc6f30a97238d0dde840a47e0481b9dbc772d0a5f36d387ff4f2fcfe17745167a84ad8b038af236ddeb72d19488c19a578f0
-  data.tar.gz: 6652bd6caa42bef616f936a7752f92e8c6e65877e37aa460dedfbb049b28c8f51b6ca0b09e74cc987e5cba6dd8ced6f7a75c4c6f222a10e20144a9b86295c625
+  metadata.gz: f165f27d0c9edd6f27918437337e47f0c47c58ccce22ca450ae121d793765f8407a6889c0ef8d02c13b7d2a5064a19bf2fd2f52f34188f0299e5330809ee1e1c
+  data.tar.gz: 70f9f6bf7bbba4e3d4e3ae6f6308ccf0e1ca24adb53c74cbe85e85935e3bb500d832e4e958611b6c3346af715204421a57f29cd4cae6f34211f47bf7b7a1979a

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/vendor/

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
 gemspec
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }

data/examples/my_app.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'mimi/db'
+require 'mimi/logger'
+
+CONFIG = {
+  db_adapter: 'sqlite3',
+  db_database: '../tmp/my_app_db',
+  db_log_level: :debug
+}.freeze
+
+Mimi::DB.configure(CONFIG)
+Mimi::DB.start
+
+class MyModel < ActiveRecord::Base
+  field :id, as: :integer, primary_key: true, not_null: true, autoincrement: true
+  field :name, as: :string, limit: 64
+  field :code, as: :string, default: -> { random_code }
+  field :value, as: :decimal, precision: 10, scale: 3
+
+  index :name
+
+  def self.random_code
+    SecureRandom.hex(16)
+  end
+end # class MyModel
+
+Mimi::DB.create_if_not_exist! # creates configured database
+Mimi::DB.update_schema!

data/lib/mimi/db/dictate/dsl.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Mimi
+  module DB
+    module Dictate
+      module DSL
+        #
+        # Declares a field on a model
+        #
+        # @example
+        #   field :id,   as: :integer, limit: 8, primary_key: true, default: 'random_uid()'
+        #
+        #   field :name # default type is :string
+        #   field :value, as: :decimal, precision: 10, scale: 3
+        #   field :ref_code, as: :string, default: -> { random_ref_code() } # application default
+        #
+        def field(name, opts = {})
+          opts = opts.dup
+          # alter model behaviour based on field properties
+          if opts[:default].is_a?(Proc)
+            field_setup_default(name, opts[:default])
+            opts.delete(:default)
+          end
+
+          # register field in the schema
+          schema_definition.field(name, opts)
+        end
+
+        # Declares and index on one or several columns
+        #
+        # @param columns [Symbol,Array<Symbol>] one or several columns
+        # @param opts [Hash] index options
+        #
+        # @example
+        #   index :name
+        #   index [:customer_id, :account_id], unique: true, name: 'idx_txs_on_customer_account'
+        #
+        def index(columns, opts = {})
+          schema_definition.index(columns, opts)
+        end
+
+        def schema_definition
+          unless self.respond_to?(:table_name)
+            raise 'Mimi::DB::Dictate.schema_definition() expects .table_name, not invoked on a Model?'
+          end
+          Mimi::DB::Dictate.schema_definitions[table_name] ||=
+            Mimi::DB::Dictate::SchemaDefinition.new(table_name)
+        end
+
+        private
+
+        # Sets up a default as a block/Proc
+        #
+        def field_setup_default(name, block)
+          before_validation on: :create do
+            self.send :"#{name}=", block.call
+          end
+        end
+      end # module DSL
+    end # module Dictate
+  end # module DB
+end # module Mimi

data/lib/mimi/db/dictate/explorer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Mimi
+  module DB
+    module Dictate
+      module Explorer
+        #
+        # Discovers a schema of an existing DB table.
+        #
+        # Returns nil if the DB table does not exist.
+        #
+        # @param table_name [String]
+        # @return [Mimi::DB::Dictate::SchemaDefinition,nil]
+        #
+        def self.discover_schema(table_name)
+          return nil unless connection.tables.include?(table_name)
+          sd = Mimi::DB::Dictate::SchemaDefinition.new(table_name)
+          discover_schema_columns(sd)
+          discover_schema_indexes(sd)
+          sd
+        end
+
+        # Discovers columns of an existing DB table and registers them in schema definition
+        #
+        # @private
+        # @param schema_definition [Mimi::DB::Dictate::SchemaDefinition]
+        #
+        def self.discover_schema_columns(schema_definition)
+          columns = connection.columns(schema_definition.table_name)
+          pk = connection.primary_key(schema_definition.table_name)
+          columns.each do |c|
+            params = {
+              as: c.type,
+              limit: c.limit,
+              primary_key: (pk == c.name),
+              auto_increment: false, # FIXME: SQLite does not report autoincremented fields
+              not_null: !c.null,
+              default: c.default,
+              sql_type: c.sql_type
+            }
+            schema_definition.field(c.name, params)
+          end
+        end
+        private_class_method :discover_schema_columns
+
+        # Discovers indexes of an existing DB table and registers them in schema definition
+        #
+        # @private
+        # @param schema_definition [Mimi::DB::Dictate::SchemaDefinition]
+        #
+        def self.discover_schema_indexes(schema_definition)
+          indexes = connection.indexes(schema_definition.table_name)
+          pk = connection.primary_key(schema_definition.table_name)
+          indexes.each do |idx|
+            params = {
+              name: idx.name,
+              primary_key:  idx.columns == [pk],
+              unique: idx.unique
+            }
+            schema_definition.index(idx.columns, params)
+          end
+        end
+        private_class_method :discover_schema_indexes
+
+        # Returns ActiveRecord DB connection
+        #
+        def self.connection
+          ActiveRecord::Base.connection
+        end
+      end # module Explorer
+    end # module Dictate
+  end # module DB
+end # module Mimi

data/lib/mimi/db/dictate/migrator.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Mimi
+  module DB
+    module Dictate
+      class Migrator
+        DEFAULTS = {
+          destructive: {
+            tables: false,
+            columns: false,
+            indexes: false
+          },
+          dry_run: false,
+          logger: nil # will use ActiveRecord::Base.logger
+        }.freeze
+
+        attr_reader :table_name, :options, :from_schema, :to_schema
+
+        # Creates a migrator to update table schema from DB state to defined state
+        #
+        # @param table_name [String,Symbol] table name
+        # @param options [Hash]
+        #
+        def initialize(table_name, options)
+          @table_name = table_name
+          @options = DEFAULTS.merge(options.dup)
+          @from_schema = self.class.db_schema_definition(table_name.to_s)
+          @to_schema   = Mimi::DB::Dictate.schema_definitions[table_name.to_s]
+          if from_schema.nil? && to_schema.nil?
+            raise "Failed to migrate '#{table_name}', no DB or target schema found"
+          end
+        end
+
+        def logger
+          @logger ||= options[:logger] || ActiveRecord::Base.logger
+        end
+
+        def db_connection
+          ActiveRecord::Base.connection
+        end
+
+        # Returns true if the Migrator is configured to do a dry run (no actual changes to DB)
+        #
+        def dry_run?
+          options[:dry_run]
+        end
+
+        # Returns true if the Migrator is permitted to do destructive operations (DROP ...)
+        # on resources identified by :key
+        #
+        def destructive?(key)
+          options[:destructive] == true ||
+            (options[:destructive].is_a?(Hash) && options[:destructive][key])
+        end
+
+        def run!
+          run_drop_table! if from_schema && to_schema.nil?
+          run_change_table! if from_schema && to_schema
+          run_create_table! if from_schema.nil? && to_schema
+          self.class.reset_db_schema_definition!(table_name)
+        end
+
+        def self.db_schema_definition(table_name)
+          db_schema_definitions[table_name] ||=
+            Mimi::DB::Dictate::Explorer.discover_schema(table_name)
+        end
+
+        def self.db_schema_definitions
+          @db_schema_definitions ||= {}
+        end
+
+        def self.reset_db_schema_definition!(table_name)
+          db_schema_definitions[table_name] = nil
+        end
+
+        private
+
+        def run_drop_table!
+          logger.info "- DROP TABLE: #{table_name}"
+          return if dry_run? || !destructive?(:tables)
+          db_connection.drop_table(table_name)
+        end
+
+        def run_change_table!
+          diff = Mimi::DB::Dictate::SchemaDiff.diff(from_schema, to_schema)
+          if diff.empty?
+            logger.info "- no changes: #{table_name}"
+            return
+          end
+          logger.info "- ALTER TABLE: #{table_name}"
+          run_change_table_columns!(diff[:columns]) if diff[:columns]
+          run_change_table_indexes!(diff[:indexes]) if diff[:indexes]
+        end
+
+        def run_change_table_columns!(diff_columns)
+          diff_columns[:remove]&.each { |c| drop_column!(table_name, c) }
+          diff_columns[:change]&.each { |c| change_column!(table_name, c) }
+          diff_columns[:add]&.each    { |c| add_column!(table_name, c) }
+        end
+
+        def run_change_table_indexes!(diff_indexes)
+          diff_indexes[:remove]&.each { |i| drop_index!(table_name, i) }
+          diff_indexes[:add]&.each    { |i| add_index!(table_name, i) }
+        end
+
+        def run_create_table!
+          columns    = to_schema.columns.values
+          column_pk  = to_schema.primary_key
+          params =
+            column_pk.params.select { |_, v| v }.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+
+          # issue CREATE TABLE with primary key field
+          logger.info "- CREATE TABLE: #{table_name}"
+          logger.info "-- add column: #{table_name}.#{column_pk.name} (#{params})"
+          unless dry_run?
+            db_connection.create_table(table_name, id: false) do |t|
+              t.column column_pk.name, column_pk.type, column_pk.params
+            end
+          end
+
+          # create rest of the columns and indexes
+          (columns - [column_pk]).each { |c| add_column!(table_name, c) }
+          to_schema.indexes.each { |i| add_index!(table_name, i) }
+        end
+
+        def drop_column!(table_name, column_name)
+          logger.info "-- drop column: #{table_name}.#{column_name}"
+          return if dry_run? || !destructive?(:columns)
+          db_connection.remove_column(table_name, column_name)
+        end
+
+        def change_column!(table_name, column)
+          params = column.params.select { |_, v| v }.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+          logger.info "-- change column: #{table_name}.#{column.name} (#{params})"
+          return if dry_run?
+          db_connection.change_column(table_name, column.name, column.type, column.params)
+        end
+
+        def add_column!(table_name, column)
+          params = column.params.select { |_, v| v }.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+          logger.info "-- add column: #{table_name}.#{column.name} (#{params})"
+          return if dry_run?
+          db_connection.add_column(table_name, column.name, column.type, column.params)
+        end
+
+        def drop_index!(table_name, idx)
+          idx_column_names = idx.columns.join(', ')
+          logger.info "-- drop index: #{idx.name} on #{table_name}(#{idx_column_names})"
+          return if dry_run?
+          db_connection.remove_index(table_name, column: idx.columns)
+        end
+
+        def add_index!(table_name, idx)
+          params = idx.params.select { |_, v| v }.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+          idx_column_names = idx.columns.join(', ')
+          logger.info "-- add index: #{idx.name} on #{table_name}(#{idx_column_names}), #{params}"
+          return if dry_run?
+          db_connection.add_index(table_name, idx.columns, idx.params)
+        end
+      end # class Migrator
+    end # module Dictate
+  end # module DB
+end # module Mimi

data/lib/mimi/db/dictate/schema_definition.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Mimi
+  module DB
+    module Dictate
+      class SchemaDefinition
+        attr_reader :table_name, :columns, :indexes
+
+        def initialize(table_name)
+          @table_name = table_name
+          @columns = {}
+          @indexes = []
+        end
+
+        def field(name, opts)
+          name = name.to_s
+          raise "Cannot redefine field :#{name}" if @columns[name]
+          if primary_key && (opts[:primary_key] || opts[:as] == :primary_key)
+            raise "Cannot redefine primary key (:#{primary_key.name}) with :#{name}"
+          end
+          @columns[name] = Column.new(name, opts)
+        end
+
+        def index(columns, opts)
+          case columns
+          when String, Symbol
+            columns = [columns.to_s]
+          when Array
+            unless columns.all? { |c| c.is_a?(String) || c.is_a?(Symbol) }
+              raise "Invalid column reference in index definition [#{columns}]"
+            end
+            columns = columns.map(&:to_s)
+          else
+            raise 'Invalid columns argument to .index'
+          end
+          if columns == [primary_key]
+            # TODO: warn the primary key index is ignored
+          end
+          @indexes << Index.new(columns, opts)
+        end
+
+        # Returns primary key column
+        #
+        # @return [Mimi::DB::Dictate::SchemaDefinition::Column]
+        #
+        def primary_key
+          pk = columns.values.find { |c| c.params[:primary_key] }
+          # raise "Primary key is not defined on '#{table_name}'" unless pk
+          pk
+        end
+
+        def to_h
+          {
+            table_name: table_name,
+            columns: columns.values.map(&:to_h),
+            indexes: indexes.map(&:to_h)
+          }
+        end
+
+        class Column
+          DEFAULTS = {
+            as: :string,
+            limit: nil,
+            primary_key: false,
+            auto_increment: false,
+            not_null: false,
+            default: nil,
+            sql_type: nil
+          }.freeze
+
+          attr_reader :name, :type, :params
+
+          def initialize(name, opts)
+            @name = name
+            @type = opts[:as] || DEFAULTS[:as]
+            type_defaults = Mimi::DB::Dictate.type_defaults(type)
+            @params = DEFAULTS.merge(type_defaults).merge(opts)
+          end
+
+          def to_h
+            {
+              name: name,
+              params: params.dup
+            }
+          end
+
+          def ==(other)
+            unless other.name == name
+              raise ArgumentError, 'Cannot compare columns with different names'
+            end
+            equal = true
+            equal &&= params[:as] == other.params[:as]
+            equal &&= params[:limit] == other.params[:limit]
+            equal &&= params[:primary_key] == other.params[:primary_key]
+            # FIXME: auto_increment ignored
+            equal &&= params[:not_null] == other.params[:not_null]
+            equal &&= params[:default] == other.params[:default]
+            # FIXME: sql_type ignored
+            equal
+          end
+        end # class Column
+
+        class Index
+          DEFAULTS = {
+            unique: false
+          }.freeze
+
+          attr_reader :name, :columns, :params
+
+          def initialize(columns, params)
+            @name = params[:name]
+            @columns = columns
+            @params = DEFAULTS.merge(params)
+          end
+
+          def to_h
+            {
+              name: name,
+              columns: columns,
+              params: params.dup
+            }
+          end
+        end # class Index
+      end # class SchemaDefinition
+    end # module Dictate
+  end # module DB
+end # module Mimi

data/lib/mimi/db/dictate/schema_diff.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Mimi
+  module DB
+    module Dictate
+      module SchemaDiff
+        DEFAULT_OPTIONS = {
+          # Force updates on fields defined as :primary_key type.
+          # If disabled, the field definition will only be used in 'CREATE TABLE'.
+          # (forced updates on :primary_key break on Postgres, at least)
+          #
+          force_primary_key: false
+        }.freeze
+
+        #
+        # Compares two schema definitions
+        #
+        # @return [Hash] :columns, :indexes => :add, :remove, :change
+        #
+        def self.diff(from, to, opts = {})
+          options = DEFAULT_OPTIONS.merge(opts)
+          from_column_names = from.columns.values.map(&:name)
+          to_column_names = to.columns.values.map(&:name)
+          columns_names_remove = from_column_names - to_column_names
+          columns_names_add    = to_column_names - from_column_names
+          columns_add          = to.columns.values.select do |c|
+            columns_names_add.include?(c.name)
+          end
+          columns_change       = to.columns.values.reject do |c|
+            res = from.columns[c.name].nil? || from.columns[c.name] == c
+            res ||= c.type == :primary_key unless options[:force_primary_key]
+          end
+          from_indexes_c = from.indexes.map(&:columns).uniq
+          to_indexes_c = to.indexes.map(&:columns).uniq
+          # ignore primary key indexes
+          from_indexes_c -= [[from.primary_key&.name]]
+          to_indexes_c -= [[to.primary_key&.name]]
+
+          indexes_c_remove = from_indexes_c - to_indexes_c
+          indexes_c_add = to_indexes_c - from_indexes_c
+          indexes_remove = from.indexes.select do |idx|
+            indexes_c_remove.include?(idx.columns)
+          end
+          indexes_add    = to.indexes.select do |idx|
+            indexes_c_add.include?(idx.columns)
+          end
+
+          diff = {}
+          unless columns_names_remove.empty?
+            diff[:columns] ||= {}
+            diff[:columns][:remove] = columns_names_remove
+          end
+          unless columns_change.empty?
+            diff[:columns] ||= {}
+            diff[:columns][:change] = columns_change
+          end
+          unless columns_add.empty?
+            diff[:columns] ||= {}
+            diff[:columns][:add] = columns_add
+          end
+          unless indexes_remove.empty?
+            diff[:indexes] ||= {}
+            diff[:indexes][:remove] = indexes_remove
+          end
+          unless indexes_add.empty?
+            diff[:indexes] ||= {}
+            diff[:indexes][:add] = indexes_add
+          end
+          diff
+        end
+      end # module SchemaDiff
+    end # module Dictate
+  end # module DB
+end # module Mimi

data/lib/mimi/db/dictate.rb

@@ -0,0 +1,90 @@
+require_relative 'dictate/dsl'
+require_relative 'dictate/schema_definition'
+require_relative 'dictate/schema_diff'
+require_relative 'dictate/explorer'
+require_relative 'dictate/migrator'
+
+module Mimi
+  module DB
+    module Dictate
+      TYPE_DEFAULTS = {
+        # sqlite3: {
+        #   string: { name: 'varchar', limit: 32 }
+        # }
+      }.freeze
+
+      def self.included(base)
+        base.extend Mimi::DB::Dictate::DSL
+      end
+
+      def self.start
+        ActiveRecord::Base.extend Mimi::DB::Dictate::DSL
+      end
+
+      def self.schema_definitions
+        @schema_definitions ||= {}
+      end
+
+      def self.adapter_type
+        ca = ActiveRecord::ConnectionAdapters
+        c  = ActiveRecord::Base.connection
+
+        # TODO: postgres???
+        return :cockroachdb if ca.const_defined?(:CockroachDBAdapter) && c.is_a?(ca::PostgreSQLAdapter)
+
+        return :postgresql if ca.const_defined?(:PostgreSQLAdapter) && c.is_a?(ca::PostgreSQLAdapter)
+
+        return :mysql if ca.const_defined?(:AbstractMysqlAdapter) && c.is_a?(ca::AbstractMysqlAdapter)
+
+        return :sqlite3 if ca.const_defined?(:SQLite3Adapter) && c.is_a?(ca::SQLite3Adapter)
+
+        raise 'Unrecognized database adapter type'
+      end
+
+      # Returns type defaults based on given type:
+      #   :string
+      #   :text
+      #   :integer etc
+      #
+      def self.type_defaults(type)
+        type = type.to_sym
+        connection_defaults = ActiveRecord::Base.connection.native_database_types
+        adapter_defaults = TYPE_DEFAULTS[DB::Dictate.adapter_type]
+        d = (adapter_defaults && adapter_defaults[type]) || connection_defaults[type] || {}
+        d = {
+          sql_type: d.is_a?(String) ? d : d[:name],
+          limit: d.is_a?(String) ? nil : d[:limit]
+        }
+        if type == :primary_key
+          d[:primary_key] = true
+          d[:not_null] = true
+        end
+        d
+      end
+
+      # Updates the DB schema to the target schema defined in models
+      #
+      # Default options from Migrator::DEFAULTS:
+      #     destructive: {
+      #       tables: false,
+      #       columns: false,
+      #       indexes: false
+      #     },
+      #     dry_run: false,
+      #     logger: nil # will use ActiveRecord::Base.logger
+      #
+      # @param opts [Hash]
+      #
+      def self.update_schema!(opts = {})
+        logger = opts[:logger] || ActiveRecord::Base.logger
+        logger.info "Mimi::DB::Dictate started updating DB schema"
+        t_start = Time.now
+        Mimi::DB.all_table_names.each { |t| Mimi::DB::Dictate::Migrator.new(t, opts).run! }
+        logger.info 'Mimi::DB::Dictate finished updating DB schema (%.3fs)' % [Time.now - t_start]
+      rescue StandardError => e
+        logger.error "DB::Dictate failed to update DB schema: #{e}"
+        raise
+      end
+    end # module Dictate
+  end # module DB
+end # module Mimi

data/lib/mimi/db/extensions.rb

@@ -2,24 +2,16 @@ module Mimi
   module DB
     module Extensions
       def self.start
-        install_bigint_primary_keys!
-        install_bigint_foreign_keys!
-      end
-
-      def self.install_bigint_primary_keys!
-        ca = ActiveRecord::ConnectionAdapters
-
-        if ca.const_defined? :PostgreSQLAdapter
-          ca::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:primary_key] = 'bigserial primary key'
-        end
+        # install DB::Dictate
+        ActiveRecord::Base.send(:include, Mimi::DB::Dictate)
 
-        if ca.const_defined? :AbstractMysqlAdapter
-          ca::AbstractMysqlAdapter::NATIVE_DATABASE_TYPES[:primary_key].gsub!(/int\(11\)/, 'bigint')
-        end
+        # FIXME: refactor DSL for primary/foreign keys
+        # install_primary_keys!
+        # install_bigint_foreign_keys!
       end
 
       def self.install_bigint_foreign_keys!
-        ActiveRecord::Base.send(:include, Mimi::DB::ForeignKey)
+        # ActiveRecord::Base.send(:include, Mimi::DB::ForeignKey)
       end
     end # module Extensions
   end # module DB

data/lib/mimi/db/foreign_key.rb

@@ -8,18 +8,23 @@ module Mimi
         # Explicitly specify a (bigint) foreign key
         #
         def foreign_key(name, opts = {})
-          opts = { as: :integer, limit: 8 }.merge(opts)
-          field(name, opts)
-          index(name)
+          # TODO: refactor and re-implement
+          raise 'Not implemented'
+
+          # opts = { as: :integer, limit: 8 }.merge(opts)
+          # field(name, opts)
+          # index(name)
         end
 
         # Redefines .belongs_to() with explicitly specified .foreign_key
         #
-        def belongs_to(name, opts = {})
-          foreign_key(:"#{name}_id")
-          # orig_belongs_to(name, opts)
-          super
-        end
+        # TODO: refactor and re-implement
+        #
+        # def belongs_to(name, opts = {})
+        #   foreign_key(:"#{name}_id")
+        #   # orig_belongs_to(name, opts)
+        #   super
+        # end
       end
     end # module ForeignKey
   end # module DB

data/lib/mimi/db/helpers.rb

@@ -10,31 +10,123 @@ module Mimi
         ActiveRecord::Base.descendants
       end
 
-      # Migrates the schema for known models
+      # Returns a list of table names defined in models
       #
-      def migrate_schema!
-        models.each(&:auto_upgrade!)
+      # @return [Array<String>]
+      #
+      def model_table_names
+        models.map(&:table_name).uniq
+      end
+
+      # Returns a list of all DB table names
+      #
+      # @return [Array<String>]
+      #
+      def db_table_names
+        ActiveRecord::Base.connection.tables
+      end
+
+      # Returns a list of all discovered table names,
+      # both defined in models and existing in DB
+      #
+      # @return [Array<String>]
+      #
+      def all_table_names
+        (model_table_names + db_table_names).uniq
+      end
+
+      # Updates the DB schema.
+      #
+      # Brings DB schema to a state defined in models.
+      #
+      # Default options from Migrator::DEFAULTS:
+      #     destructive: {
+      #       tables: false,
+      #       columns: false,
+      #       indexes: false
+      #     },
+      #     dry_run: false,
+      #     logger: nil # will use ActiveRecord::Base.logger
+      #
+      # @example
+      #   # only detect and report planned changes
+      #   Mimi::DB.update_schema!(dry_run: true)
+      #
+      #   # modify the DB schema, including all destructive operations
+      #   Mimi::DB.update_schema!(destructive: true)
+      #
+      def update_schema!(opts = {})
+        opts[:logger] ||= Mimi::DB.logger
+        Mimi::DB::Dictate.update_schema!(opts)
       end
 
       # Creates the database specified in the current configuration.
       #
       def create!
+        db_adapter = Mimi::DB.active_record_config['adapter']
+        db_database = Mimi::DB.active_record_config['database']
+        slim_url = "#{db_adapter}//<host>:<port>/#{db_database}"
+        Mimi::DB.logger.info "Mimi::DB.create! creating database: #{slim_url}"
+        original_stdout = $stdout
+        original_stderr = $stderr
+        $stdout = StringIO.new
+        $stderr = StringIO.new
         ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
         ActiveRecord::Tasks::DatabaseTasks.create(Mimi::DB.active_record_config)
+        Mimi::DB.logger.debug "Mimi::DB.create! out:#{$stdout.string}, err:#{$stderr.string}"
+      ensure
+        $stdout = original_stdout
+        $stderr = original_stderr
+      end
+
+      # Tries to establish connection, returns true if the database exist
+      #
+      def database_exist?
+        ActiveRecord::Base.establish_connection(Mimi::DB.active_record_config)
+        ActiveRecord::Base.connection
+        true
+      rescue ActiveRecord::NoDatabaseError
+        false
+      end
+
+      # Creates the database specified in the current configuration, if it does NOT exist.
+      #
+      def create_if_not_exist!
+        if database_exist?
+          Mimi::DB.logger.debug 'Mimi::DB.create_if_not_exist! database exists, skipping...'
+          return
+        end
+        create!
       end
 
       # Drops the database specified in the current configuration.
       #
       def drop!
+        original_stdout = $stdout
+        original_stderr = $stderr
+        $stdout = StringIO.new
+        $stderr = StringIO.new
         ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
         ActiveRecord::Tasks::DatabaseTasks.drop(Mimi::DB.active_record_config)
+        Mimi::DB.logger.debug "Mimi::DB.drop! out:#{$stdout.string}, err:#{$stderr.string}"
+      ensure
+        $stdout = original_stdout
+        $stderr = original_stderr
       end
 
       # Clears (but not drops) the database specified in the current configuration.
       #
       def clear!
+        original_stdout = $stdout
+        original_stderr = $stderr
+        $stdout = StringIO.new
+        $stderr = StringIO.new
         ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
         ActiveRecord::Tasks::DatabaseTasks.purge(Mimi::DB.active_record_config)
+        Mimi::DB.logger.debug "Mimi::DB.clear! out:#{$stdout.string}, err:#{$stderr.string}"
+      ensure
+        $stdout = original_stdout
+        $stderr = original_stderr
       end
 
       # Executes raw SQL, with variables interpolation.

data/lib/mimi/db/version.rb

@@ -1,5 +1,5 @@
 module Mimi
   module DB
-    VERSION = '0.1.4'.freeze
+    VERSION = '0.2.1'.freeze
   end
 end

data/lib/mimi/db.rb

@@ -1,6 +1,5 @@
 require 'mimi/core'
 require 'active_record'
-require 'mini_record'
 
 module Mimi
   module DB
@@ -15,7 +14,11 @@ module Mimi
       db_username: nil,
       db_password: nil,
       db_log_level: :info,
-      db_pool: 15
+      db_pool: 15,
+      db_primary_key_cockroachdb: nil,
+      db_primary_key_postgresql: nil,
+      db_primary_key_mysql: nil,
+      db_primary_key_sqlite3: nil
       # db_encoding:
     )
 
@@ -62,9 +65,12 @@ module Mimi
 
     def self.configure(*)
       super
+      ActiveSupport::LogSubscriber.colorize_logging = false
       ActiveRecord::Base.logger = logger
       ActiveRecord::Base.configurations = { 'default' => active_record_config }
-      ActiveRecord::Base.raise_in_transactional_callbacks = true
+
+      # TODO: test and remove deprectated ...
+      # ActiveRecord::Base.raise_in_transactional_callbacks = true
     end
 
     def self.logger
@@ -74,6 +80,7 @@ module Mimi
     def self.start
       ActiveRecord::Base.establish_connection(:default)
       Mimi::DB::Extensions.start
+      Mimi::DB::Dictate.start
       Mimi.require_files(module_options[:require_files]) if module_options[:require_files]
       super
     end
@@ -98,3 +105,4 @@ require_relative 'db/version'
 require_relative 'db/extensions'
 require_relative 'db/helpers'
 require_relative 'db/foreign_key'
+require_relative 'db/dictate'

data/lib/tasks/db.rake

@@ -49,8 +49,14 @@ namespace :db do
 
     desc 'Migrate database (schema only)'
     task schema: :"db:start" do
-      logger.info "* Migrating database #{Mimi::DB.module_options[:db_database]}"
-      Mimi::DB.migrate_schema!
+      logger.info "* Updating database schema: #{Mimi::DB.module_options[:db_database]}"
+      Mimi::DB.update_schema!(destructive: true)
+    end
+
+    desc 'Migrate database (schema only) (DRY RUN)'
+    task schema: :"db:start" do
+      logger.info "* Updating database schema (DRY RUN): #{Mimi::DB.module_options[:db_database]}"
+      Mimi::DB.update_schema!(destructive: true, dry_run: true)
     end
   end
 end

data/mimi-db.gemspec

@@ -27,12 +27,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'mimi-core', '~> 0.1'
-  spec.add_dependency 'activerecord', '~> 4.2'
-  spec.add_dependency 'mini_record', '~> 0.4'
+  spec.add_dependency 'mimi-core', '~> 0.2'
+  spec.add_dependency 'mimi-logger', '~> 0.2'
+  spec.add_dependency 'activerecord', '~> 5.0'
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'sqlite3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mimi-db
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.1
 platform: ruby
 authors:
 - Alex Kukushkin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-17 00:00:00.000000000 Z
+date: 2018-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mimi-core
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: mimi-logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: mini_record
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Database module for mimi, microframework for microservices
 email:
 - alex@kukushk.in
@@ -125,7 +139,14 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/my_app.rb
 - lib/mimi/db.rb
+- lib/mimi/db/dictate.rb
+- lib/mimi/db/dictate/dsl.rb
+- lib/mimi/db/dictate/explorer.rb
+- lib/mimi/db/dictate/migrator.rb
+- lib/mimi/db/dictate/schema_definition.rb
+- lib/mimi/db/dictate/schema_diff.rb
 - lib/mimi/db/extensions.rb
 - lib/mimi/db/foreign_key.rb
 - lib/mimi/db/helpers.rb
@@ -157,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.14.1
 signing_key: 
 specification_version: 4
 summary: Database module for mimi, microframework for microservices