umbrellio-sequel-plugins 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 229f4459fc1056833cae7449c6026400155af8129235cb6d2c26fe0c6e9896a3
+  data.tar.gz: 8306b1fc77f37c9e199b8fcaa4a22260580956213d0f0fe50c989627247556a9
+SHA512:
+  metadata.gz: 6b2f765b0f6c292477724a56da513a94df92d424687684d3cf1690850989d42255f6897bb153f5f62710001bcfe29eb962aec38cd6f2013f8ecb98d79088b2ff
+  data.tar.gz: b4800cd9102df26f9d53036228d1617e646f31bbffb408b5a48feedc218ad7c4cbb6917b20e3e42bb0ed3b1935502b1a6a0bff5038686c2c86d87d15848bf3c2

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,10 @@
+inherit_gem:
+  rubocop-config-umbrellio: lib/rubocop.yml
+
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.4
+
+Naming/FileName:
+  Exclude:
+    - lib/sequel-plugins.rb

data/.travis.yml

@@ -0,0 +1,27 @@
+language: ruby
+
+sudo: false
+
+rvm:
+  - 2.4
+  - 2.5
+  - 2.6
+  - ruby-head
+
+services:
+  - postgresql
+addons:
+  postgresql: 9.6
+before_install: gem install bundler
+before_script:
+  - psql -c 'create database sequel_plugins;' -U postgres
+script:
+  - bundle exec rspec
+  - bundle exec rubocop
+
+matrix:
+  fast_finish: true
+  allow_failures:
+    - rvm: ruby-head
+
+cache: bundler

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+group :development, :test do
+  gem "rubocop-config-umbrellio", github: "umbrellio/code-style"
+end
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Umbrellio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,249 @@
+# SequelPlugins
+[![Build Status](https://travis-ci.org/umbrellio/umbrellio-sequel-plugins.svg?branch=master)](https://travis-ci.org/umbrellio/umbrellio-sequel-plugins)
+[![Coverage Status](https://coveralls.io/repos/github/umbrellio/umbrellio-sequel-plugins/badge.svg?branch=master)](https://coveralls.io/github/umbrellio/umbrellio-sequel-plugins?branch=master)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'umbrellio-sequel-plugins'
+```
+
+And then execute:
+
+    $ bundle
+
+# Extensions
+
+- CurrencyRates
+- PGTools
+- Slave
+- Synchronize
+
+# Plugins
+
+- Duplicate
+- GetColumnValue
+- StoreAccessors
+- Synchronize
+- Upsert
+- WithLock
+
+# Tools
+- TimestampMigratorUndoExtension
+
+## CurrencyRates
+
+Plugin for joining currency rates table to any other table and money exchange.
+
+Enable: `DB.extension :currency_rates`
+
+Currency rates table example:
+
+```sql
+CREATE TABLE currency_rates (
+    id integer NOT NULL,
+    currency text NOT NULL,
+    period tsrange NOT NULL,
+    rates jsonb NOT NULL
+);
+
+INSERT INTO currency_rates (currency, period, rates) VALUES
+('EUR', tsrange('2019-02-07 16:00:00 +0300', '2019-02-07 16:00:00 +0300'), '{"USD": 1.1, "EUR": 1.0, "RUB": 81}'),
+('EUR', tsrange('2019-02-07 17:00:00 +0300', NULL), '{"USD": 1.2, "EUR": 1.0, "RUB": 75}')
+```
+
+Usage example:
+
+```sql
+CREATE TABLE items (
+    id integer NOT NULL,
+    currency text NOT NULL,
+    price numeric NOT NULL,
+    created_at timestamp without time zone NOT NULL
+);
+
+INSERT INTO items (currency, price, created_at) VALUES ("EUR", 10, '2019-02-07 16:10:00 +0300')
+```
+
+```ruby
+DB[:items]
+    .with_rates
+    .select(Sequel[:price].exchange_to("USD").as(:usd_price))
+    .first
+# => { "usd_price" => 12.0 }
+```
+
+
+## PGTools
+
+Enable: `DB.extension :pg_tools`
+
+### `#inherited_tables_for`
+
+Plugins for getting all inherited tables.
+
+Example:
+
+```ruby
+DB.inherited_tables_for(:event_log) # => [:event_log_2019_01, :event_log_2019_02]
+```
+
+## Slave
+
+Enable: `DB.extension :slave`
+
+Plugin for choosing slave server for query.
+
+Example:
+
+```ruby
+DB[:users].slave.where(email: "test@test.com") # executes on a slave server
+```
+
+**Important:** you have to define a server named 'slave' in sequel config before using it.
+
+
+## Synchronize
+
+Enable: `DB.extension :synchronize`
+
+Plugin for using transaction advisory locks for application-level mutexes.
+
+Example:
+
+```ruby
+DB.synchronize_with([:ruby, :forever]) { p "Hey, I'm in transaction!"; sleep 5 }
+# => BEGIN
+# => SELECT pg_try_advisory_xact_lock(3764656399) -- 'ruby-forever'
+# => COMMIT
+```
+
+## Duplicate
+
+Enable: `Sequel::Model.plugin :duplicate`
+
+Model plugin for creating a copies.
+
+Example:
+
+```ruby
+User = Sequel::Model(:users)
+user1 = User.create(name: "John")
+user2 = user1.duplicate(name: "James")
+user2.name # => "James"
+```
+OR
+
+```ruby
+user2 = User.duplicate(user1, name: "James")
+user2.name # => "James"
+```
+
+## GetColumnValue
+
+Enable: `Sequel::Model.plugin :get_column_value`
+
+Plugin for getting raw column value
+
+Example:
+
+```ruby
+item = Item.first
+item.price # => #<Money fractional:5000.0 currency:USD>
+item.get_column_value(:amount) # => 0.5e2
+```
+
+## StoreAccessors
+
+Enable: `Sequel::Model.plugin :store_accessors`
+
+Plugin for using jsonb field keys as model properties.
+
+Example:
+
+```ruby
+class User < Sequel::Model
+   store :data, :first_name
+end
+
+user = User.create(first_name: "John")
+user.first_name # => "John"
+user.data # => {"first_name": "John"}
+```
+
+## Synchronize
+
+**Important:** requires a `synchronize` extension described above.
+
+Same as `DB#synchronize_with`
+
+Enable: 
+
+```ruby
+DB.extension :synchronize
+Sequel::Model.plugin :synchronize
+```
+
+Example: 
+
+```ruby
+user = User.first
+user.synchronize([:ruby, :forever]) { p "Hey, I'm in transaction!"; sleep 5 }
+```
+
+## Upsert
+
+Enable: `Sequel::Model.plugin :upsert`
+
+Plugin for create an "UPSERT" requests to database.
+
+Example:
+
+```ruby
+User.upsert(name: "John", email: "jd@test.com", target: :email)
+User.upsert_dataset.insert(name: "John", email: "jd@test.com")
+```
+
+## WithLock
+
+Enable: `Sequel::Model.plugin :with_lock`
+
+Plugin for locking row for update.
+
+Example:
+
+```ruby
+user = User.first
+user.with_lock do
+    user.update(name: "James")
+end
+```
+
+## TimestampMigratorUndoExtension
+Allows to undo a specific migration
+
+Example:
+
+```ruby
+m = Sequel::TimestampMigrator.new(DB, "db/migrations")
+m.undo(1549624163) # 1549624163 is a migration version
+```
+
+Also you can use `sequel:undo` rake task for it.
+Example:
+
+```sh
+rake sequel:undo VERSION=1549624163
+```
+
+## License
+Released under MIT License.
+
+## Authors
+Created by Aleksey Bespalov.
+
+<a href="https://github.com/umbrellio/">
+  <img style="float: left;" src="https://umbrellio.github.io/Umbrellio/supported_by_umbrellio.svg" alt="Supported by Umbrellio" width="439" height="72">
+</a>

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sequel"
+require "irb"
+require_relative "../database"
+
+Dir["#{__dir__}/lib/**/*.rb"].each { |f| require f }
+
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/database.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+::DB ||= Sequel.connect(ENV["DB_URL"] || "postgres://localhost/sequel_plugins")
+Sequel::Model.db = DB
+DB.extension :pg_array
+DB.extension :pg_json
+DB.extension :pg_range
+
+DB.extension :currency_rates
+DB.extension :pg_tools
+DB.extension :slave
+DB.extension :synchronize
+
+Sequel.extension :migration
+Sequel.extension :pg_array_ops
+Sequel.extension :pg_json_ops
+Sequel.extension :pg_range_ops
+
+Sequel::Model.plugin :duplicate
+Sequel::Model.plugin :get_column_value
+Sequel::Model.plugin :store_accessors
+Sequel::Model.plugin :synchronize
+Sequel::Model.plugin :upsert
+Sequel::Model.plugin :with_lock
+
+def clean_database!
+  DB.tables.each do |table_name|
+    DB.drop_table?(table_name, cascade: true)
+  end
+end

data/lib/sequel-plugins.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "sequel_plugins.rb"

data/lib/sequel/extensions/currency_rates.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Sequel
+  # Extension for currency-conversion via currency_rates table
+  module CurrencyRates
+    # Join a rates table
+    #
+    # @param aliaz [Symbol] alias to be used for joined table
+    # @param table [Symbol] table name to join to
+    # @param time_column [Symbol] time column by which table is joined
+    #
+    # @example
+    #   Order::Model.with_rates.select(Sequel[:amount].in_usd)
+    # @return [Sequel::Dataset] dataset
+    def with_rates(
+      aliaz = :currency_rates,
+      table: table_name,
+      rates_table: Sequel[:currency_rates],
+      time_column: :created_at
+    )
+      table = Sequel[table]
+      rates = Sequel[aliaz]
+      join_expr = table[:currency] =~ rates[:currency]
+      join_expr &= rates[:period].pg_range.contains(table[time_column])
+      left_join(rates_table.as(aliaz), join_expr)
+    end
+
+    # Returns a table name
+    #
+    # @return [Symbol] table name
+    def table_name
+      respond_to?(:first_source_alias) ? first_source_alias : super
+    end
+  end
+
+  module CurrencyRateExchange
+    # Exchange column value to a specific currency
+    #
+    # @param currency [String] currency
+    # @param rates_table [Symbol] rates table name
+    #
+    # @example
+    #   Sequel[:amount].exchange_to("EUR", :order_rates)
+    # @return [Sequel::SQL::NumericExpression]
+    def exchange_to(currency, rates_table = :currency_rates)
+      rate = Sequel[rates_table][:rates].pg_jsonb.get_text(currency).cast_numeric(Float)
+      self * rate
+    end
+
+    # Exchange column value to usd
+    #
+    # @param opts (see #exchange_to)
+    #
+    # @example
+    #   Sequel[:amount].in_usd
+    # @return (see #exchange_to)
+    def in_usd(*opts)
+      exchange_to("USD", *opts)
+    end
+  end
+
+  Model.extend(CurrencyRates)
+  SQL::GenericExpression.include(CurrencyRateExchange)
+  Dataset.register_extension(:currency_rates, CurrencyRates)
+end

data/lib/sequel/extensions/pg_tools.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sequel
+  # Extension with some tools that use pg internal tables and views
+  module PGTools
+    # List inherited tables for specific parent table
+    #
+    # @param table_name [String, Symbol] name of the parent table
+    # @param schema [String, Symbol] schema of the parent table, defaults to +:public+
+    #
+    # @example
+    #   DB.inherited_tables_for(:event_log)
+    #   # => [:event_log_2019_01, :event_log_2019_02]
+    #
+    #   DB.inherited_tables_for(:event_log, schema: :foo)
+    #   # => []
+    # @return [Array<Symbol>] list of inhertied tables
+    def inherited_tables_for(table_name, schema: :public)
+      self[:pg_inherits]
+        .select(Sequel[:cn][:nspname].as(:schema), Sequel[:c][:relname].as(:child))
+        .left_join(Sequel[:pg_class].as(:c), Sequel[:inhrelid] => Sequel[:c][:oid])
+        .left_join(Sequel[:pg_class].as(:p), Sequel[:inhparent] => Sequel[:p][:oid])
+        .left_join(Sequel[:pg_namespace].as(:pn), Sequel[:pn][:oid] => Sequel[:p][:relnamespace])
+        .left_join(Sequel[:pg_namespace].as(:cn), Sequel[:cn][:oid] => Sequel[:c][:relnamespace])
+        .where(Sequel[:p][:relname] => table_name.to_s, Sequel[:pn][:nspname] => schema.to_s)
+        .to_a
+        .map { |x| x[:child].to_sym }
+    end
+  end
+
+  Database.register_extension(:pg_tools, PGTools)
+end

data/lib/sequel/extensions/slave.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sequel
+  # Extension for choosing a slave server
+  module Slave
+    # Turn to slave
+    #
+    # @example
+    #   DB[:users].slave.where(email: "test@test.com") # executes on a slave server
+    # @return [Sequel::Dataset] dataset
+    def slave
+      server(:slave)
+    end
+  end
+
+  Model.extend(Slave)
+  Dataset.register_extension(:slave, Slave)
+end

data/lib/sequel/extensions/synchronize.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Sequel
+  # Allows you to use PostgreSQL transaction advisory locks for application-level mutexes
+  module Synchronize
+    AdvisoryLockTimeoutError = Class.new(StandardError)
+    LOCK_RETRY_INTERVAL = 0.5
+
+    # Use transaction advisory lock for block of code
+    #
+    # @param *args [Array[Strings]] used for build lock name (just join with "-")
+    # @param timeout: [Integer] hot much time (in seconds) to wait lock
+    # @param savepoint: [Boolean] transaction with savepoint or not.
+    # @param skip_if_locked: [Boolean]
+    #
+    # @example
+    #   DB.synchronize_with([:ruby, :forever]) { p "Hey, I'm in transaction!"; sleep 5 }
+    # @db_output
+    # => BEGIN
+    # => SELECT pg_try_advisory_xact_lock(3764656399) -- 'ruby-forever'
+    # => COMMIT
+    def synchronize_with(*args, timeout: 10, savepoint: false, skip_if_locked: false)
+      key = lock_key_for(args)
+
+      transaction(savepoint: savepoint) do
+        hash = key_hash(key)
+        if get_lock(key, hash, timeout: timeout, skip_if_locked: skip_if_locked)
+          log_info("locked with #{key} (#{hash})")
+          yield
+        end
+      end
+    end
+
+    private
+
+    def get_lock(key, hash, timeout:, skip_if_locked:)
+      return acquire_lock(key, hash) if skip_if_locked
+
+      Timeout.timeout(timeout, AdvisoryLockTimeoutError, timeout_error_message(key, timeout)) do
+        loop do
+          return true if acquire_lock(key, hash)
+          sleep LOCK_RETRY_INTERVAL
+        end
+      end
+    end
+
+    def lock_key_for(args)
+      args.to_a.flatten.join("-")
+    end
+
+    def key_hash(key)
+      Digest::MD5.hexdigest(key)[0..7].hex
+    end
+
+    def timeout_error_message(key, timeout)
+      "Timeout exceeded for #{key} (#{timeout} seconds)"
+    end
+
+    def acquire_lock(key, hash)
+      self["SELECT pg_try_advisory_xact_lock(?) -- ?", hash, key].get
+    end
+  end
+
+  Database.register_extension(:synchronize, Synchronize)
+end

data/lib/sequel/plugins/duplicate.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Sequel analog for `ActiveRecord::Base#dup` method
+module Sequel::Plugins::Duplicate
+  module ClassMethods
+    # Returns a copy of current model
+    #
+    # @param model [Sequel::Model] source object
+    # @param new_attrs [Hash] attributes to override
+    #
+    # @return [Sequel::Model]
+    def duplicate(model, **new_attrs)
+      pk = *primary_key
+      attrs = model.values.reject { |key, *| pk.include?(key) }
+      new(**attrs, **new_attrs)
+    end
+  end
+
+  module InstanceMethods
+    # Returns a copy of current model
+    #
+    # @param new_attrs [Hash] attributes to override
+    #
+    # @return [Sequel::Model]
+    def duplicate(**new_attrs)
+      self.class.duplicate(self, **new_attrs)
+    end
+  end
+end

data/lib/sequel/plugins/get_column_value.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Sequel uses send by default
+module Sequel::Plugins::GetColumnValue
+  module InstanceMethods
+    # Returns a raw column value
+    #
+    # @example
+    #   o = Order::Model.first
+    #   o.amount # => #<Money fractional:5000.0 currency:USD>
+    #   o.get_column_value(:amount) # => 0.5e2
+    # @return value
+    def get_column_value(value)
+      self[value]
+    end
+  end
+end

data/lib/sequel/plugins/store_accessors.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Creates accessors for json values
+module Sequel::Plugins::StoreAccessors
+  module ClassMethods
+    # Setup a store
+    #
+    # @param column [Symbol] jsonb column
+    # @param fields [Array<Symbol>] keys in json, which will be accessors
+    # @example
+    #   class User < Sequel::Model
+    #      store :data, :first_name
+    #   end
+    #
+    #   user = User.create(first_name: "John")
+    #   user.first_name # => "John"
+    #   user.data # => {"first_name": "John"}
+    def store(column, *fields)
+      include_accessors_module
+
+      fields.each do |field|
+        define_store_getter(column, field)
+        define_store_setter(column, field)
+      end
+    end
+
+    private
+
+    def include_accessors_module
+      return if defined?(@_store_accessors_module)
+      @_store_accessors_module = Module.new
+      include @_store_accessors_module
+    end
+
+    def define_store_getter(column, field)
+      @_store_accessors_module.module_eval do
+        define_method(field) do
+          send(column).to_h[field.to_s]
+        end
+      end
+    end
+
+    def define_store_setter(column, field)
+      @_store_accessors_module.module_eval do
+        define_method("#{field}=") do |value|
+          send("#{column}=", send(column).to_h.merge(field.to_s => value))
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/synchronize.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Allows you to use PostgreSQL transaction advisory locks for application-level mutexes
+module Sequel::Plugins::Synchronize
+  module ClassMethods
+    # Watch Sequel::Synchronize#synchronize_with
+    def synchronize_with(*args, &block)
+      db.extension(:synchronize).synchronize_with(*args, &block)
+    end
+  end
+
+  module InstanceMethods
+    # Just like Sequel::Synchronize#synchronize_with,
+    # but name, which is joined from args, is combined with table_name and primary_key
+    def synchronize(*args, **options)
+      self.class.synchronize_with(lock_key_for(args), **options) { yield(reload) }
+    end
+
+    private
+
+    def lock_key_for(args)
+      [self.class.table_name, self[primary_key], *args].flatten.join("-")
+    end
+  end
+end

data/lib/sequel/plugins/upsert.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Sequel::Plugins::Upsert
+  module ClassMethods
+    # Returns an upsert dataset
+    #
+    # @param target [Symbol] target column
+    # @example
+    #   User.upsert_dataset.insert(name: "John", email: "jd@test.com")
+    #
+    # @return [Sequel::Dataset] dataset
+    def upsert_dataset(target: primary_key)
+      cols = columns - Array(primary_key)
+      update_spec = cols.map { |x| [x, Sequel[:excluded][x]] }
+      where_spec = cols.map { |x| [Sequel[table_name][x], Sequel[:excluded][x]] }
+
+      dataset.insert_conflict(
+        target: target,
+        update: update_spec,
+        update_where: Sequel.~(where_spec),
+      )
+    end
+
+    # Executes the upsert request
+    #
+    # @param row [Hash] values
+    # @param options [Hash] options
+    #
+    # @example
+    #   User.upsert(name: "John", email: "jd@test.com", target: :email)
+    # @return [Sequel::Model]
+    def upsert(row, **options)
+      upsert_dataset(**options).insert(sequel_values(row))
+    end
+
+    # Executes the upsert request for multiple rows
+    # @see #upsert
+    # @see #upsert_dataset
+    def multi_upsert(rows, **options)
+      rows = rows.map { |row| sequel_values(row) }
+      upsert_dataset(options).multi_insert(rows)
+    end
+
+    # Returns formatted row values
+    #
+    # @param row [Hash]
+    #
+    # @return [Hash]
+    def sequel_values(row)
+      upsert_model.new(row).values
+    end
+
+    # Returns upsert model for current table
+    #
+    # @return [Sequel::Model]
+    def upsert_model
+      @upsert_model ||= Sequel::Model(table_name)
+    end
+  end
+end

data/lib/sequel/plugins/with_lock.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sequel::Plugins::WithLock
+  module InstanceMethods
+    # Execute block with lock
+    #
+    # @yield
+    def with_lock
+      return yield if @__locked
+      @__locked = true
+
+      begin
+        db.transaction do
+          lock!
+          yield
+        end
+      ensure
+        @__locked = false
+      end
+    end
+  end
+end

data/lib/sequel/timestamp_migrator_undo_extension.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "logger"
+
+# rubocop:disable Layout/ClassStructure
+module Sequel
+  class TimestampMigrator
+    # Rollback a migration
+    def undo(version)
+      path = files.find { |file| migration_version_from_file(get_filename(file)) == version }
+      raise "Migration #{version} does not exist in the filesystem" unless path
+
+      filename = get_filename(path)
+      raise "Migration #{version} is not applied" unless applied_migrations.include?(filename)
+
+      migration = get_migration(path)
+
+      time = Time.now
+      db.log_info("Undoing migration #{filename}")
+
+      checked_transaction(migration) do
+        migration.apply(db, :down)
+        ds.filter(column => filename).delete
+      end
+
+      elapsed = format("%0.6f", Time.now - time)
+      db.log_info("Finished undoing migration #{filename}, took #{elapsed} seconds")
+    end
+
+    module TimestampMigratorLogger
+      # Setup the logger
+      def run
+        db.loggers << Logger.new($stdout, level: :info)
+        level = db.sql_log_level
+        db.sql_log_level = :debug
+        db.log_info("Begin applying migrations")
+        super
+      ensure
+        db.sql_log_level = level
+        db.loggers.pop
+      end
+    end
+
+    Sequel::TimestampMigrator.prepend TimestampMigratorLogger
+
+    private
+
+    def get_migration(path)
+      migration = load_migration_file(path)
+
+      return migration if Gem::Version.new(Sequel.version) >= Gem::Version.new("5.6")
+      # :nocov:
+      Migration.descendants.last
+      # :nocov:
+    end
+
+    def get_filename(path)
+      File.basename(path).downcase
+    end
+  end
+end
+# rubocop:enable Layout/ClassStructure

data/lib/sequel_plugins.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SequelPlugins
+  if defined?(::Rails)
+    Engine = Class.new(::Rails::Engine)
+  end
+end

data/lib/tasks/sequel/rollback_missing_migrations.rake

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "sequel/timestamp_migrator_undo_extension"
+
+namespace :sequel do
+  # Rollback migrations that are absent in revision when deploying on staging
+  task rollback_missing_migrations: :environment do
+    # Extract migrations
+    def extract_migrations(path)
+      Dir.glob("#{path}/db/migrate/*.rb").map { |filename| File.basename(filename).to_i }
+    end
+
+    old_migrations = extract_migrations(ENV["OLD_RELEASE"])
+    new_migrations = extract_migrations(ENV["NEW_RELEASE"])
+    migrations_to_rollback = old_migrations - new_migrations
+
+    next if migrations_to_rollback.empty?
+
+    puts "Rolling back migrations:"
+    puts migrations_to_rollback
+
+    path = ::Rails.root.join("db/migrate")
+    migrator = Sequel::TimestampMigrator.new(DB, path, allow_missing_migration_files: true)
+    applied_migrations = migrator.applied_migrations.map(&:to_i)
+    migrations = applied_migrations.select { |m| m.in?(migrations_to_rollback) }.sort.reverse
+
+    migrations.each { |migration| migrator.undo(migration) }
+  end
+end

data/lib/tasks/sequel/undo.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "sequel/timestamp_migrator_undo_extension"
+
+namespace :sequel do
+  # Rollback a specific migration
+  task undo: :environment do
+    version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+    raise "VERSION is required" unless version
+
+    path = ::Rails.root.join("db/migrate")
+    migrator = Sequel::TimestampMigrator.new(DB, path, allow_missing_migration_files: true)
+    migrator.undo(version)
+  end
+end

data/umbrellio-sequel-plugins.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name = "umbrellio-sequel-plugins"
+  spec.version = "0.1.0"
+  spec.authors = ["nulldef"]
+  spec.email = ["nulldefiner@gmail.com"]
+  spec.required_ruby_version = ">= 2.4"
+
+  spec.summary = "Sequel plugins"
+  spec.description = "Sequel plugins"
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sequel"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "pg"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: umbrellio-sequel-plugins
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- nulldef
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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'
+- !ruby/object:Gem::Dependency
+  name: pg
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Sequel plugins
+email:
+- nulldefiner@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- database.rb
+- lib/sequel-plugins.rb
+- lib/sequel/extensions/currency_rates.rb
+- lib/sequel/extensions/pg_tools.rb
+- lib/sequel/extensions/slave.rb
+- lib/sequel/extensions/synchronize.rb
+- lib/sequel/plugins/duplicate.rb
+- lib/sequel/plugins/get_column_value.rb
+- lib/sequel/plugins/store_accessors.rb
+- lib/sequel/plugins/synchronize.rb
+- lib/sequel/plugins/upsert.rb
+- lib/sequel/plugins/with_lock.rb
+- lib/sequel/timestamp_migrator_undo_extension.rb
+- lib/sequel_plugins.rb
+- lib/tasks/sequel/rollback_missing_migrations.rake
+- lib/tasks/sequel/undo.rake
+- umbrellio-sequel-plugins.gemspec
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Sequel plugins
+test_files: []