effective_resources 1.8.21 → 1.8.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aedd54df5d6ebf911041fedaa519ab1f8fde409e6bed5fd9374e6b9460ef2506
-  data.tar.gz: bd179f5ee32166042cd5e0f011b40e5738b7a7ec3abca222ce778c4ac69e20cc
+  metadata.gz: 594bd0ccce4fd20ed2b9a47b8212f4db0d092f6aaa7852dfa0b54d6eb8dac303
+  data.tar.gz: 066fa3be8c2cf7300517a7ca377496bed75516ec7e91dcc8e2b5bcd8a8185a8e
 SHA512:
-  metadata.gz: 97a13796ce565f1b05891c1b92382eaaaa8677846d60add08dd23cdc2577b883bfc285b2b8f6b3d64fb39fff1fd3acd36143f476375d08bd1740f1d1003b62d3
-  data.tar.gz: af4e9d7d6332731e7d5f6d7c6a0e17ec0c0d07aecff8d000e41ac9446b27b013c60fd218dcca846d06bf1f15bc3463b694f6e61c5b8784e10eb8c2d1efeab35d
+  metadata.gz: 9b92e61316487db82714da4ffffb7c7bc85f7de4027ba9ababf9b2f42df9d70391b4cbfb4884dd8dfb86f7a5a567ff24d815af2a73f7bc9b1a58ae3b296f1e4e
+  data.tar.gz: dfdcafafd72ffff2c629b47b61ac7d4e80c588962dcebc3c0d74dadc3131c9e121690bb73afcb60ae2fd309f2ba790faa44c832713a33505c428f87fa4c31398

data/app/models/concerns/effective_after_commit.rb

@@ -0,0 +1,29 @@
+# EffectiveAfterCommit
+#
+# Execute code after the ActiveRecord transaction has committed
+# Inspired by https://github.com/Envek/after_commit_everywhere
+#
+# This is automatically included into ActiveRecord::Base
+#
+# after_commit { MyMailer.welcome.deliver_later }
+
+module EffectiveAfterCommit
+  extend ActiveSupport::Concern
+
+  module Base
+    def after_commit(connection: self.class.connection, &callback)
+      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback, no_tx_action: :execute)
+    end
+
+    def before_commit(connection: self.class.connection, &callback)
+      raise(NotImplementedError, "#{__method__} works only with Rails 5.0+") if ActiveRecord::VERSION::MAJOR < 5
+      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback, no_tx_action: :warn_and_execute)
+    end
+
+    def after_rollback(connection: self.class.connection, &callback)
+      raise('expected a block') unless block_given?
+      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback, no_tx_action: :exception)
+    end
+  end
+
+end

data/app/models/effective/after_commit.rb

@@ -0,0 +1,48 @@
+module Effective
+  class AfterCommit
+
+    def initialize(**handlers)
+      @handlers = handlers
+    end
+
+    def has_transactional_callbacks?
+      true
+    end
+
+    def trigger_transactional_callbacks?
+      true
+    end
+
+    def before_committed!(*)
+      @handlers[:before_commit]&.call
+    end
+
+    def committed!(args)
+      @handlers[:after_commit]&.call
+    end
+
+    def rolledback!(*)
+      @handlers[:after_rollback]&.call
+    end
+
+    def self.register_callback(connection:, name:, no_tx_action:, callback:)
+      raise ArgumentError, "#{name} expected a block" unless callback
+
+      unless (connection.transaction_open? && connection.current_transaction.joinable?)
+        case no_tx_action
+        when :warn_and_execute
+          warn "#{name}: No transaction open. Executing callback immediately."
+          return callback.call
+        when :execute
+          return callback.call
+        when :exception
+          raise("#{name} is useless outside transaction")
+        end
+      end
+
+      after_commit = Effective::AfterCommit.new("#{name}": callback)
+      connection.add_transaction_record(after_commit)
+    end
+
+  end
+end

data/app/models/effective/http.rb

@@ -0,0 +1,111 @@
+module Effective
+  class Http
+
+    def self.get(endpoint, params: nil, headers: nil)
+      headers = { 'Content-Type': 'application/json' }.merge(headers || {})
+      query = ('?' + params.compact.map { |k, v| "$#{k}=#{v}" }.join('&')) if params.present?
+
+      uri = URI.parse(endpoint + query.to_s)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = 10
+      http.use_ssl = true if endpoint.start_with?('https')
+
+      response = with_retries do
+        puts "[GET] #{uri}" if Rails.env.development?
+        http.get(uri, headers)
+      end
+
+      unless ['200', '204'].include?(response.code.to_s)
+        puts("Response code: #{response.code} #{response.body}")
+        return false
+      end
+
+      JSON.parse(response.body)
+    end
+
+    def self.post(endpoint, params:, headers: nil)
+      headers = { 'Content-Type': 'application/json' }.merge(headers || {})
+
+      uri = URI.parse(endpoint)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = 10
+      http.use_ssl = true if endpoint.start_with?('https')
+
+      response = with_retries do
+        puts "[POST] #{uri} #{params}" if Rails.env.development?
+        http.post(uri.path, params.to_json, headers)
+      end
+
+      unless ['200', '204'].include?(response.code.to_s)
+        puts("Response code: #{response.code} #{response.body}")
+        return false
+      end
+
+      JSON.parse(response.body)
+    end
+
+    def self.patch(endpoint, params:, headers: nil)
+      headers = { 'Content-Type': 'application/json' }.merge(headers || {})
+
+      uri = URI.parse(endpoint)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = 10
+      http.use_ssl = true if endpoint.start_with?('https')
+
+      response = with_retries do
+        puts "[PATCH] #{uri} #{params}" if Rails.env.development?
+        http.post(uri.path, params.to_json, headers)
+      end
+
+      unless ['200', '204'].include?(response.code.to_s)
+        puts("Response code: #{response.code} #{response.body}")
+        return false
+      end
+
+      JSON.parse(response.body)
+    end
+
+    def self.delete(endpoint, params: nil, headers: nil)
+      headers = { 'Content-Type': 'application/json' }.merge(headers || {})
+      query = ('?' + params.compact.map { |k, v| "$#{k}=#{v}" }.join('&')) if params.present?
+
+      uri = URI.parse(endpoint + query.to_s)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = 10
+      http.use_ssl = true if endpoint.start_with?('https')
+
+      response = with_retries do
+        puts "[DELETE] #{uri}" if Rails.env.development?
+        http.delete(uri, headers)
+      end
+
+      unless ['200', '204'].include?(response.code.to_s)
+        puts("Response code: #{response.code} #{response.body}")
+        return false
+      end
+
+      JSON.parse(response.body)
+    end
+
+    private
+
+    def self.with_retries(retries: 3, wait: 2, &block)
+      raise('expected a block') unless block_given?
+
+      begin
+        return yield
+      rescue Exception => e
+        if (retries -= 1) > 0
+          sleep(wait); retry
+        else
+          raise
+        end
+      end
+    end
+
+  end
+end

data/app/models/effective/model_reader.rb

@@ -11,6 +11,11 @@ module Effective
       @attributes = {}
     end
 
+    # For EffectiveLogging. This is a protected keyword I think.
+    def message(*args)
+      method_missing(:message, args)
+    end
+
     def read(&block)
       instance_exec(&block)
     end

data/app/models/effective/resources/attributes.rb

@@ -105,8 +105,10 @@ module Effective
         attributes = (klass.new().attributes rescue nil)
         return [] unless attributes
 
-        names = attributes.keys - belong_tos.map { |reference| reference.foreign_key }
-        names = names - [klass.primary_key, 'created_at', 'updated_at'] unless all
+        names = attributes.keys
+        names -= belong_tos.map { |reference| reference.foreign_key }
+        names -= belong_tos.map { |reference| reference.foreign_type if reference.options[:polymorphic] }
+        names -= [klass.primary_key, 'created_at', 'updated_at'] unless all
 
         attributes = names.inject({}) do |h, name|
           if klass.respond_to?(:column_for_attribute) # Rails 4+

data/app/models/effective/resources/sql.rb

@@ -8,7 +8,7 @@ module Effective
       end
 
       def columns
-        klass.columns
+        klass.respond_to?(:columns) ? klass.columns : []
       end
 
       def column_names
@@ -40,9 +40,11 @@ module Effective
       def sql_type(name)
         name = name.to_s.split('.').first
 
-        if belongs_to(name)
-          :belongs_to
-        elsif (column = column(name))
+        return :belongs_to if belongs_to(name)
+
+        column = column(name)
+
+        if column.present?
           column.type
         elsif has_many(name)
           :has_many

data/lib/effective_resources/engine.rb

@@ -32,6 +32,7 @@ module EffectiveResources
 
         ActiveRecord::Base.extend(EffectiveDeviseUser::Base)
         ActiveRecord::Base.extend(EffectiveResource::Base)
+        ActiveRecord::Base.include(EffectiveAfterCommit::Base)
       end
     end
 

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '1.8.21'.freeze
+  VERSION = '1.8.26'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 1.8.21
+  version: 1.8.26
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-19 00:00:00.000000000 Z
+date: 2021-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -157,13 +157,16 @@ files:
 - app/models/concerns/acts_as_statused.rb
 - app/models/concerns/acts_as_tokened.rb
 - app/models/concerns/acts_as_wizard.rb
+- app/models/concerns/effective_after_commit.rb
 - app/models/concerns/effective_devise_user.rb
 - app/models/concerns/effective_resource.rb
 - app/models/concerns/has_many_rich_texts.rb
 - app/models/effective/access_denied.rb
 - app/models/effective/action_failed.rb
+- app/models/effective/after_commit.rb
 - app/models/effective/attribute.rb
 - app/models/effective/code_reader.rb
+- app/models/effective/http.rb
 - app/models/effective/model_reader.rb
 - app/models/effective/resource.rb
 - app/models/effective/resource_exec.rb