sequel-activerecord_connection 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8c039d5e631eab07727b3ae6f451bc04656a5f5215a1c3389c64dead44a16f2e
+  data.tar.gz: 99402da40ca6bbbadc05dd1dfd24757368a6153a85922b705cd491c14ab54096
+SHA512:
+  metadata.gz: 6312fad7666b13a9fb6d670ef5b1806edb4cda9843b008090f69a8f5472982673f1180a16b5e903f0e26eab7ef6cdba3d9d6a762024ef28842d17f61f9d5ac68
+  data.tar.gz: e80315a652b89d0cb13075dc72ade8d882f3a35038f998293bfbb8f3aeed8483457e80ed085fa850694e5694fbc10a7e6641ad35bd66f3df01bdb9b3e9dc21d8

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Janko Marohnić
+
+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,202 @@
+# Sequel::ActiveRecordConnection
+
+This is an extension for [Sequel] that allows it to reuse an existing
+ActiveRecord connection for database interaction. It supports `postgresql`,
+`mysql2` and `sqlite3` adapters.
+
+This can be useful if you're using a library that uses Sequel for database
+interaction (e.g. [Rodauth]), but you want to avoid creating a separate
+database connection. Or if you're transitioning from ActiveRecord to Sequel,
+and want the database connection to be shared.
+
+Note that this is a best-effort implementation, so some discrepancies are still
+possible. That being said, this implementation passes [Rodauth]'s test suite
+(for all adapters), which has fairly advanced Sequel usage.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "sequel-activerecord_connection"
+```
+
+And then execute:
+
+```sh
+$ bundle install
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install sequel-activerecord_connection
+```
+
+## Usage
+
+Assuming you've configured your ActiveRecord connection, you can initialize the
+appropriate Sequel adapter and load the `activerecord_connection` extension:
+
+```rb
+require "sequel"
+
+DB = Sequel.postgres(test: false) # avoid creating a connection
+DB.extension :activerecord_connection
+```
+
+Now any Sequel operations that you make will internaly be done using the
+ActiveRecord connection, so you should see the queries in your ActiveRecord
+logs.
+
+```rb
+DB.create_table :posts do
+  primary_key :id
+  String :title, null: false
+  Stirng :body, null: false
+end
+
+DB[:posts].insert(
+  title: "Sequel::ActiveRecordConnection",
+  body:  "Allows Sequel to reuse ActiveRecord's connection",
+)
+#=> 1
+
+DB[:posts].all
+#=> [{ title: "Sequel::ActiveRecordConnection", body: "Allows Sequel to reuse ActiveRecord's connection" }]
+
+DB[:posts].update(title: "sequel-activerecord_connection")
+#=> 1
+```
+
+The database extension supports `postgresql`, `mysql2` and `sqlite3`
+ActiveRecord adapters, just make sure to initialize the corresponding Sequel
+adapter before loading the extension.
+
+```rb
+DB = Sequel.postgres(test: false) # for "postgresql" adapter
+# or
+DB = Sequel.mysql2(test: false) # for "mysql2" adapter
+# or
+DB = Sequel.sqlite(test: false) # for "sqlite3" adapter
+```
+
+### Transactions
+
+The database extension overrides Sequel transactions to use ActiveRecord
+transcations, which allows using ActiveRecord inside Sequel transactions (and
+vice-versa), and have things like ActiveRecord's transactional callbacks still
+work correctly.
+
+```rb
+DB.transaction do
+  ActiveRecord::Base.transaction do
+    # this all works
+  end
+end
+```
+
+The following Sequel transaction options are currently supported:
+
+* `:savepoint`
+* `:auto_savepoint`
+* `:rollback`
+
+```rb
+ActiveRecord::Base.transaction do
+  DB.transaction(savepoint: true) do # will create a savepoint
+    DB.transaction do # will not create a savepoint
+      # ...
+    end
+  end
+end
+```
+
+The `#in_transaction?` method is supported as well:
+
+```rb
+ActiveRecord::Base.transaction do
+  DB.in_transaction? #=> true
+end
+```
+
+Other transaction-related Sequel methods (`#after_commit`, `#after_rollback`
+etc) are not supported, because ActiveRecord currently doesn't provide
+transactional callbacks on the connection level (only on the model level).
+
+### Exceptions
+
+To ensure Sequel compatibility, any `ActiveRecord::StatementInvalid` exceptions
+will be translated into Sequel exceptions:
+
+```rb
+DB[:posts].multi_insert [{ id: 1 }, { id: 1 }]
+#~> Sequel::UniqueConstraintViolation
+
+DB[:posts].insert(title: nil)
+#~> Sequel::NotNullConstraintViolation
+
+DB[:posts].insert(author_id: 123)
+#~> Sequel::ForeignKeyConstraintViolation
+```
+
+### Model
+
+By default, the connection configuration will be read from `ActiveRecord::Base`.
+If you want to use connection configuration from a different model, you can
+can assign it to the database object after loading the extension:
+
+```rb
+class MyModel < ActiveRecord::Base
+  connects_to database: { writing: :animals, reading: :animals_replica }
+end
+```
+```rb
+DB.activerecord_model = MyModel
+```
+
+### Timezone
+
+Sequel's database timezone will be automatically set to ActiveRecord's default
+timezone when the extension(`:utc` by default) when the extension is loaded.
+
+If you happen to be changing ActiveRecord's default timezone after you've
+loaded the extension, make sure to reflect that in your Sequel database object,
+for example:
+
+```rb
+DB.timezone = :local
+```
+
+## Tests
+
+You'll first want to run the rake tasks for setting up databases and users:
+
+```sh
+$ rake db_setup_postgres
+$ rake db_setup_mysql
+```
+
+Then you can run the tests:
+
+```sh
+$ rake test
+```
+
+When you're done, you can delete the created databases and users:
+
+```sh
+$ rake db_teardown_postgres
+$ rake db_teardown_mysql
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in this project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/janko/sequel-activerecord-adapter/blob/master/CODE_OF_CONDUCT.md).
+
+[Sequel]: https://github.com/jeremyevans/sequel
+[Rodauth]: https://github.com/jeremyevans/rodauth

data/lib/sequel/extensions/activerecord_connection.rb

@@ -0,0 +1,77 @@
+module Sequel
+  module ActiveRecordConnection
+    Error = Class.new(Sequel::Error)
+
+    def self.extended(db)
+      db.activerecord_model = ActiveRecord::Base
+      db.timezone = ActiveRecord::Base.default_timezone
+
+      begin
+        require "sequel/extensions/activerecord_connection/#{db.adapter_scheme}"
+        db.extend Sequel::ActiveRecordConnection.const_get(db.adapter_scheme.capitalize)
+      rescue LoadError
+        fail Error, "unsupported adapter: #{db.adapter_scheme}"
+      end
+    end
+
+    attr_accessor :activerecord_model
+
+    # Ensure Sequel is not creating its own connection anywhere.
+    def connect(*)
+      raise Error, "creating a Sequel connection is not allowed"
+    end
+
+    def transaction(savepoint: nil, rollback: nil, auto_savepoint: nil, server: nil, **options)
+      fail Error, "#{options} transaction options are currently not supported" unless options.empty?
+
+      if in_transaction?
+        requires_new = savepoint || Thread.current[:sequel_activerecord_auto_savepoint]
+      else
+        requires_new = true
+      end
+
+      activerecord_model.transaction(requires_new: requires_new) do
+        begin
+          Thread.current[:sequel_activerecord_auto_savepoint] = true if auto_savepoint
+          yield
+        rescue Sequel::Rollback => exception
+          raise if rollback == :reraise
+          raise ActiveRecord::Rollback, exception.message, exception.backtrace
+        ensure
+          Thread.current[:sequel_activerecord_auto_savepoint] = nil if auto_savepoint
+        end
+
+        raise ActiveRecord::Rollback if rollback == :always
+      end
+    end
+
+    def in_transaction?(*)
+      activerecord_connection.transaction_open?
+    end
+
+    %i[after_commit after_rollback rollback_on_exit rollback_checker].each do |meth|
+      define_method(meth) do |*|
+        fail Error, "Database##{meth} is currently not supported"
+      end
+    end
+
+    # Avoid calling Sequel's connection pool, instead use ActiveRecord.
+    def synchronize(*)
+      activerecord_connection.lock.synchronize do
+        yield activerecord_raw_connection
+      end
+    end
+
+    private
+
+    def activerecord_raw_connection
+      activerecord_connection.raw_connection
+    end
+
+    def activerecord_connection
+      activerecord_model.connection
+    end
+  end
+
+  Database.register_extension(:activerecord_connection, ActiveRecordConnection)
+end

data/lib/sequel/extensions/activerecord_connection/mysql2.rb

@@ -0,0 +1,35 @@
+module Sequel
+  module ActiveRecordConnection
+    module Mysql2
+      def execute(sql, opts=OPTS)
+        original_query_options = activerecord_raw_connection.query_options.dup
+
+        activerecord_raw_connection.query_options.merge!(
+          as:             :hash,
+          symbolize_keys: true,
+          cache_rows:     false,
+        )
+
+        result = activerecord_connection.execute(sql)
+
+        if opts[:type] == :select
+          if block_given?
+            yield result
+          else
+            result
+          end
+        elsif block_given?
+          yield activerecord_raw_connection
+        end
+      rescue ActiveRecord::StatementInvalid => exception
+        if exception.cause.is_a?(::Mysql2::Error)
+          raise_error(exception.cause)
+        else
+          raise
+        end
+      ensure
+        activerecord_raw_connection.query_options.replace(original_query_options)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/activerecord_connection/postgres.rb

@@ -0,0 +1,19 @@
+module Sequel
+  module ActiveRecordConnection
+    module Postgres
+      def execute(sql, opts=OPTS)
+        result = activerecord_connection.execute(sql)
+
+        if block_given?
+          yield result
+        else
+          result.cmd_tuples
+        end
+      rescue ActiveRecord::StatementInvalid => exception
+        raise_error(exception.cause, classes: database_error_classes)
+      ensure
+        result.clear if result
+      end
+    end
+  end
+end

data/lib/sequel/extensions/activerecord_connection/sqlite.rb

@@ -0,0 +1,40 @@
+module Sequel
+  module ActiveRecordConnection
+    module Sqlite
+      def execute_ddl(sql, opts=OPTS)
+        execute(sql, opts)
+      end
+
+      private
+
+      # ActiveRecord doesn't send SQLite methods Sequel expects, so we need to
+      # try to replicate what ActiveRecord does around connection excecution.
+      def _execute(type, sql, opts, &block)
+        activerecord_raw_connection.extended_result_codes = true
+
+        activerecord_connection.materialize_transactions
+
+        activerecord_connection.send(:log, sql) do
+          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+            case type
+            when :select
+              activerecord_raw_connection.query(sql, &block)
+            when :insert
+              activerecord_raw_connection.execute(sql)
+              activerecord_raw_connection.last_insert_row_id
+            when :update
+              activerecord_raw_connection.execute_batch(sql)
+              activerecord_raw_connection.changes
+            end
+          end
+        end
+      rescue ActiveRecord::StatementInvalid => exception
+        if exception.cause.is_a?(SQLite3::Exception)
+          raise_error(exception.cause)
+        else
+          raise exception
+        end
+      end
+    end
+  end
+end

data/sequel-activerecord_connection.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |spec|
+  spec.name          = "sequel-activerecord_connection"
+  spec.version       = "0.2.0"
+  spec.authors       = ["Janko Marohnić"]
+  spec.email         = ["janko.marohnic@gmail.com"]
+
+  spec.summary       = %q{Allows Sequel to use ActiveRecord connection for database interaction.}
+  spec.description   = %q{Allows Sequel to use ActiveRecord connection for database interaction.}
+  spec.homepage      = "https://github.com/janko/sequel-activerecord_connection"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.2.0")
+
+  spec.add_dependency "sequel", "~> 5.0"
+  spec.add_dependency "activerecord", ">= 5.0", "< 7"
+
+  spec.add_development_dependency "pg",      "~> 1.0"
+  spec.add_development_dependency "mysql2",  "~> 0.5"
+  spec.add_development_dependency "sqlite3", "~> 1.4"
+  spec.add_development_dependency "minitest"
+
+  spec.files         = Dir["README.md", "LICENSE.txt", "CHANGELOG.md", "lib/**/*.rb", "*.gemspec"]
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: sequel-activerecord_connection
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Janko Marohnić
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: Allows Sequel to use ActiveRecord connection for database interaction.
+email:
+- janko.marohnic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/sequel/extensions/activerecord_connection.rb
+- lib/sequel/extensions/activerecord_connection/mysql2.rb
+- lib/sequel/extensions/activerecord_connection/postgres.rb
+- lib/sequel/extensions/activerecord_connection/sqlite.rb
+- sequel-activerecord_connection.gemspec
+homepage: https://github.com/janko/sequel-activerecord_connection
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.1
+signing_key: 
+specification_version: 4
+summary: Allows Sequel to use ActiveRecord connection for database interaction.
+test_files: []