mimi-db 0.2.7 → 0.3.0

data/lib/mimi/db/dictate.rb

@@ -3,65 +3,26 @@ require_relative 'dictate/schema_definition'
 require_relative 'dictate/schema_diff'
 require_relative 'dictate/explorer'
 require_relative 'dictate/migrator'
+require_relative 'dictate/type_defaults'
 
 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
 
+      # Returns all registered schema definitions
+      #
+      # @return [Hash] a map of <table_name> -> <schema_definition>
+      #
       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:
@@ -71,18 +32,18 @@ module Mimi
       #       indexes: false
       #     },
       #     dry_run: false,
-      #     logger: nil # will use ActiveRecord::Base.logger
+      #     logger: nil # will use Mimi::DB.logger
       #
       # @param opts [Hash]
       #
       def self.update_schema!(opts = {})
-        logger = opts[:logger] || ActiveRecord::Base.logger
-        logger.info "Mimi::DB::Dictate started updating DB schema"
+        logger = opts[:logger] || Mimi::DB.logger
+        logger.debug '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]
+        logger.debug '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}"
+        logger.error "Mimi::DB::Dictate failed to update DB schema: #{e}"
         raise
       end
 
@@ -92,22 +53,23 @@ module Mimi
       # @return [Hash]
       #
       def self.diff_schema(opts = {})
-        logger = opts[:logger] || ActiveRecord::Base.logger
-        diff = { add_tables: [], change_tables: [], drop_tables: []}
+        logger = opts[:logger] || Mimi::DB.logger
+        diff = { add_tables: [], change_tables: [], drop_tables: [] }
         Mimi::DB.all_table_names.each do |t|
           m = Mimi::DB::Dictate::Migrator.new(t, opts)
           if m.from_schema && m.to_schema.nil?
             diff[:drop_tables] << t
           elsif m.from_schema && m.to_schema
+            logger.debug "DB::Dictate comparing '#{t}'"
             t_diff = Mimi::DB::Dictate::SchemaDiff.diff(m.from_schema, m.to_schema)
             diff[:change_tables] << t_diff unless t_diff[:columns].empty? && t_diff[:indexes].empty?
-          elsif m.from_schema.nil? &&  m.to_schema
+          elsif m.from_schema.nil? && m.to_schema
             diff[:add_tables] << m.to_schema
           end
         end
         diff
       rescue StandardError => e
-        logger.error "DB::Dictate failed to update DB schema: #{e}"
+        logger.error "DB::Dictate failed to compare schema: #{e}"
         raise
       end
     end # module Dictate

data/lib/mimi/db/extensions/sequel-cockroachdb.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'sequel/adapters/postgres'
+
+module Sequel
+  #
+  # A simplistic and not fully functional CockroachDB adapter
+  #
+  # TODO: to replace with a better alternative once available
+  #
+  module Cockroach
+    class Database < Sequel::Postgres::Database
+      set_adapter_scheme :cockroach
+      set_adapter_scheme :cockroachdb
+
+      # Cockroach DB only supports one savepoint
+      def supports_savepoints?
+        false
+      end
+
+      def server_version(*)
+        80000 # mimics Postgres v8
+        # 100000 # mimics Postgres v10
+      end
+
+      private
+
+      def dataset_class_default
+        Dataset
+      end
+    end
+
+    class Dataset < Sequel::Postgres::Dataset
+      def default_timestamp_format
+        "'%Y-%m-%d %H:%M:%S%N%:z'"
+      end
+    end # class Dataset
+  end # module Cockroach
+end # module Sequel

data/lib/mimi/db/extensions/sequel-database.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'sequel'
+
+module Sequel
+  class Database
+    #
+    # Fixed behaviour for Sequel's log_exception()
+    #
+    # Reason:
+    #   * handled exceptions should not be logged as errors
+    #   * unhandled exceptions will be logged at the application level
+    #
+    def log_exception(exception, message, *)
+      text_message = "#{self.class}(#{exception.class}): #{exception.message}"
+      logger_message = { m: text_message, sql: message }
+
+      # In case logger does not support structured data, implement a #to_s method
+      logger_message.define_singleton_method(:to_s) { text_message }
+      log_each(:debug, logger_message)
+    end
+  end # class Database
+end # module Sequel

data/lib/mimi/db/extensions/sequel-postgres.rb

@@ -0,0 +1,3 @@
+# require 'sequel/adapters/postgres'
+
+# Extensions to Postgres adapter

data/lib/mimi/db/extensions/sequel-sqlite.rb

@@ -0,0 +1,3 @@
+# require 'sequel/adapters/sqlite'
+
+# Extensions to Postgres adapter

data/lib/mimi/db/extensions.rb

@@ -2,16 +2,20 @@ module Mimi
   module DB
     module Extensions
       def self.start
-        # install DB::Dictate
-        ActiveRecord::Base.send(:include, Mimi::DB::Dictate)
-
-        # 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)
+        adapter_name = Mimi::DB.sequel_config[:adapter]
+        require_relative 'extensions/sequel-database'
+        case adapter_name
+        when 'sqlite'
+          require_relative 'extensions/sequel-sqlite'
+        when 'postgres'
+          require_relative 'extensions/sequel-postgres'
+        when 'cockroachdb'
+          require_relative 'extensions/sequel-postgres'
+          require_relative 'extensions/sequel-cockroachdb'
+        else
+          # load nothing
+        end
+        Sequel::Model.plugin :timestamps
       end
     end # module Extensions
   end # module DB

data/lib/mimi/db/foreign_key.rb

@@ -1,20 +1,22 @@
 module Mimi
   module DB
     module ForeignKey
-      extend ActiveSupport::Concern
+      # TODO: refactor and re-implement
 
-      class_methods do
+      # extend ActiveSupport::Concern
+
+      # class_methods do
         #
         # Explicitly specify a (bigint) foreign key
         #
-        def foreign_key(name, opts = {})
-          # TODO: refactor and re-implement
-          raise 'Not implemented'
+        # def foreign_key(name, opts = {})
+
+          # raise 'Not implemented'
 
           # opts = { as: :integer, limit: 8 }.merge(opts)
           # field(name, opts)
           # index(name)
-        end
+        # end
 
         # Redefines .belongs_to() with explicitly specified .foreign_key
         #
@@ -25,7 +27,7 @@ module Mimi
         #   # orig_belongs_to(name, opts)
         #   super
         # end
-      end
+      # end
     end # module ForeignKey
   end # module DB
 end # module Mimi

data/lib/mimi/db/helpers.rb

@@ -7,7 +7,7 @@ module Mimi
       # @return [Array<ActiveRecord::Base>]
       #
       def models
-        ActiveRecord::Base.descendants
+        Mimi::DB::Model.descendants
       end
 
       # Returns a list of table names defined in models
@@ -23,7 +23,7 @@ module Mimi
       # @return [Array<String>]
       #
       def db_table_names
-        ActiveRecord::Base.connection.tables
+        Mimi::DB.connection.tables
       end
 
       # Returns a list of all discovered table names,
@@ -56,6 +56,7 @@ module Mimi
       #   Mimi::DB.update_schema!(destructive: true)
       #
       def update_schema!(opts = {})
+        Mimi::DB.start
         opts[:logger] ||= Mimi::DB.logger
         Mimi::DB::Dictate.update_schema!(opts)
       end
@@ -84,6 +85,7 @@ module Mimi
       # @return [Hash]
       #
       def diff_schema(opts = {})
+        Mimi::DB.start
         opts[:logger] ||= Mimi::DB.logger
         Mimi::DB::Dictate.diff_schema(opts)
       end
@@ -91,29 +93,16 @@ module Mimi
       # 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
+        raise 'Not implemented'
       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
+        Mimi::DB.connection.test_connection
         true
-      rescue ActiveRecord::NoDatabaseError
+      rescue StandardError => e
+        Mimi::DB.logger.error "DB: database_exist? failed with: #{e}"
         false
       end
 
@@ -130,31 +119,17 @@ module Mimi
       # 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
+        raise 'Not implemented'
       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
+        Mimi::DB.start
+        db_table_names.each do |table_name|
+          Mimi::DB.logger.debug "Mimi::DB dropping table: #{table_name}"
+          Mimi::DB.connection.drop_table(table_name)
+        end
       end
 
       # Executes raw SQL, with variables interpolation.
@@ -163,8 +138,31 @@ module Mimi
       #   Mimi::DB.execute('insert into table1 values(?, ?, ?)', 'foo', :bar, 123)
       #
       def execute(statement, *args)
-        sql = ActiveRecord::Base.send(:replace_bind_variables, statement, args)
-        ActiveRecord::Base.connection.execute(sql)
+        sql = Sequel.fetch(statement, *args).sql
+        Mimi::DB.connection.run(sql)
+      end
+
+      # Starts a transaction and executes a given block within the transaction
+      #
+      # @param params [Hash] parameters to Sequel #transaction() method
+      #
+      def transaction(params = {}, &_block)
+        unless Mimi::DB.connection
+          raise 'Failed to start transaction, Mimi::DB.connection not available'
+        end
+        Mimi::DB.connection.transaction(params) { yield }
+      end
+
+      # Executes a block with a given DB log level
+      #
+      # @param log_level [Symbol,nil] :debug, :info etc
+      #
+      def with_log_level(log_level, &_block)
+        current_log_level = Mimi::DB.connection.sql_log_level
+        Mimi::DB.connection.sql_log_level = log_level
+        yield
+      ensure
+        Mimi::DB.connection.sql_log_level = current_log_level
       end
     end # module Helpers
 

data/lib/mimi/db/lock.rb

@@ -49,6 +49,10 @@ module Mimi
       end
 
       def lock!(name, opts = {}, &block)
+        raise 'Not implemented'
+
+        # FIXME: migrate Mimi::DB::Lock to Sequel
+
         opts = Mimi::DB::Lock.module_options[:default_lock_options].merge(opts.dup)
         adapter_name = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
         case adapter_name

data/lib/mimi/db/model.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# NOTE: this is the way to create an abstract class that inherits from Sequel::Model
+Mimi::DB::Model = Class.new(Sequel::Model)
+
+module Mimi
+  module DB
+    class Model
+      include Mimi::DB::Dictate
+
+      self.require_valid_table = false
+      plugin :timestamps, create: :created_at, update: :updated_at, update_on_create: true
+      plugin :validation_helpers
+
+      # Keeps messages as error types, not human readable strings
+      #
+      def default_validation_helpers_options(type)
+        { message: type }
+      end
+
+      def before_validation
+        super
+        call_hooks(:before_validation)
+      end
+
+      # Defines a hook the ActiveRecord way
+      #
+      # Example:
+      #
+      #   class A < Mimi::DB::Model
+      #     before_validation :set_detaults
+      #
+      #     def set_defaults
+      #       self.name = "John Doe"
+      #     end
+      #   end
+      #
+      def self.before_validation(method = nil, &block)
+        if method && block
+          raise ArgumentError, '.before_validation() cannot accept both method and a block'
+        end
+        block = -> { send(method) } if method
+        register_hook(:before_validation, block)
+      end
+
+      private
+
+      def self.registered_hooks(name)
+        @registered_hooks ||= {}
+        @registered_hooks[name] ||= []
+      end
+
+      def self.register_hook(name, block)
+        registered_hooks(name) << block
+      end
+
+      def call_hooks(name)
+        self.class.registered_hooks(name).each do |block|
+          instance_eval(&block)
+        end
+      end
+    end # class Model
+  end # module DB
+end # module Mimi

data/lib/mimi/db/version.rb

@@ -1,5 +1,5 @@
 module Mimi
   module DB
-    VERSION = '0.2.7'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

data/lib/mimi/db.rb

@@ -1,5 +1,5 @@
 require 'mimi/core'
-require 'active_record'
+require 'sequel'
 
 module Mimi
   module DB
@@ -13,12 +13,8 @@ module Mimi
       db_port: nil,
       db_username: nil,
       db_password: nil,
-      db_log_level: :info,
-      db_pool: 15,
-      db_primary_key_cockroachdb: nil,
-      db_primary_key_postgresql: nil,
-      db_primary_key_mysql: nil,
-      db_primary_key_sqlite3: nil
+      db_log_level: :debug,
+      db_pool: 15
       # db_encoding:
     )
 
@@ -58,45 +54,75 @@ module Mimi
         },
         db_log_level: {
           desc: 'Logging level for database layer ("debug", "info" etc)',
-          default: 'info'
+          default: 'debug'
         }
       }
     end
 
     def self.configure(*)
       super
-      ActiveSupport::LogSubscriber.colorize_logging = false
-      ActiveRecord::Base.logger = logger
-      ActiveRecord::Base.configurations = { 'default' => active_record_config }
-
-      # TODO: test and remove deprectated ...
-      # ActiveRecord::Base.raise_in_transactional_callbacks = true
+      if Mimi.const_defined?(:Application)
+        @logger = Mimi::Application.logger
+      end
     end
 
     def self.logger
-      @logger ||= Mimi::Logger.new(level: module_options[:db_log_level])
+      @logger ||= Mimi::Logger.new
+    end
+
+    # Returns active DB connection
+    #
+    # @return [Sequel::<...>::Database]
+    #
+    def self.connection
+      @connection
     end
 
     def self.start
-      ActiveRecord::Base.establish_connection(:default)
       Mimi::DB::Extensions.start
-      Mimi::DB::Dictate.start
+      @connection = Sequel.connect(sequel_config)
       Mimi.require_files(module_options[:require_files]) if module_options[:require_files]
       super
     end
 
-    def self.active_record_config
+    # Returns a standard Sequel adapter name converted from any variation of adapter names.
+    #
+    # @example
+    #   sequel_config_canonical_adapter_name(:sqlite3) # => 'sqlite'
+    #
+    # @param adapter_name [String,Symbol]
+    # @return [String]
+    #
+    def self.sequel_config_canonical_adapter_name(adapter_name)
+      case adapter_name.to_s.downcase
+      when 'sqlite', 'sqlite3'
+        'sqlite'
+      when 'postgres', 'postgresql'
+        'postgres'
+      when 'cockroach', 'cockroachdb'
+        'cockroachdb'
+      else
+        adapter_name.to_s.downcase
+      end
+    end
+
+    # Returns Sequel connection parameters
+    #
+    # @return [Hash]
+    #
+    def self.sequel_config
       {
-        adapter: module_options[:db_adapter],
+        adapter: sequel_config_canonical_adapter_name(module_options[:db_adapter]),
         database: module_options[:db_database],
         host: module_options[:db_host],
         port: module_options[:db_port],
-        username: module_options[:db_username],
+        user: module_options[:db_username],
         password: module_options[:db_password],
         encoding: module_options[:db_encoding],
-        pool: module_options[:db_pool],
-        reaping_frequency: 15
-      }.stringify_keys
+        max_connections: module_options[:db_pool],
+        sql_log_level: module_options[:db_log_level],
+        logger: logger
+      }
     end
   end # module DB
 end # module Mimi
@@ -106,3 +132,4 @@ require_relative 'db/extensions'
 require_relative 'db/helpers'
 require_relative 'db/foreign_key'
 require_relative 'db/dictate'
+require_relative 'db/model'

data/lib/tasks/db.rake

@@ -40,17 +40,22 @@ namespace :db do
   namespace :migrate do
     desc 'Migrate database (seeds only)'
     task seeds: :"db:start" do
+      logger.info "* Processing database seeds: #{Mimi::DB.module_options[:db_database]}"
+      t_start = Time.now
       seeds = Pathname.glob(Mimi.app_path_to('db', 'seeds', '**', '*.rb')).sort
       seeds.each do |seed_filename|
-        logger.info "* Processing seed: #{seed_filename}"
+        logger.info "-- Processing seed: #{seed_filename}"
         load seed_filename
       end
+      logger.info '* Finished processing database seeds (%.3fs)' % (Time.now - t_start)
     end
 
     desc 'Migrate database (schema only)'
     task schema: :"db:start" do
       logger.info "* Updating database schema: #{Mimi::DB.module_options[:db_database]}"
+      t_start = Time.now
       Mimi::DB.update_schema!(destructive: true)
+      logger.info '* Finished updating database schema (%.3fs)' % (Time.now - t_start)
     end
 
     namespace :schema do
@@ -88,6 +93,9 @@ namespace :db do
         diff[:drop_tables].each do |t|
           puts "-- DROP table: #{t}"
         end
+        if diff[:add_tables].empty? && diff[:change_tables].empty? && diff[:drop_tables].empty?
+          logger.info '* Diff database schema: no changes detected'
+        end
       end
     end
   end

data/mimi-db.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'mimi-core', '~> 0.2'
   spec.add_dependency 'mimi-logger', '~> 0.2'
-  spec.add_dependency 'activerecord', '~> 5.0'
+  spec.add_dependency 'sequel', '~> 5.8'
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'