associate_jsonb 0.0.1 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad94cc18f8d5f87d25f2ebe9d0b75309fb43a3f22fc1438266e05ce39c2a3064
-  data.tar.gz: 016ce6443d9fdca1155d4b63fc18e6f6aaa18ef8887f73fe22312ee876d65f5d
+  metadata.gz: f0832e64c43e22ba206a98d0603c0e231c1606b17315f715a4050e19a1fdb21b
+  data.tar.gz: ff37b2777adf131f20ad9a95076d8797ecf30dc2ddeaa86913de5a457cf9fed4
 SHA512:
-  metadata.gz: 7534ab4739036cff3691d4da6ac3d612cb6149c948088a3b7c24095e10bafce0d98e4bd96b7276c1ce84fd5e1017f039af48d59ed7d29f42827e90379a5e277d
-  data.tar.gz: 97e169f1942e48131f7de7be8dc99551c525fbdec7914a3de26abe3738614f1ae838bbd3edf2fb8828097c60ae32a47546638053f447510b4ad3792677dd639b
+  metadata.gz: 00fbd32bc9e66fa8bd85fcf9cab51850bc65443a99f66dbc3bcff5ca5d05e855624c62ac9a0aa7bcbed330a2650dbe149806c49bc3bb40ecd3aa6cdf002fde19
+  data.tar.gz: b134266f93576482f3558be28840081b803982ce369bd75497af2d9d2d2db30e3c27364247485ef2a4712705fb01183d80b812f6fa28f18d8f7db37db555bb88

data/README.md

@@ -2,7 +2,87 @@
 
 [![Gem Version](https://badge.fury.io/rb/associate_jsonb.svg)](https://badge.fury.io/rb/associate_jsonb)
 
-Basic ActiveRecord Associations using PostgreSQL JSONB columns, with built-in accessors and column indexes
+#### PostgreSQL JSONB extensions including:
+  - Basic ActiveRecord Associations using PostgreSQL JSONB columns, with built-in accessors and column indexes
+  - Thread-Safe JSONB updates (well, as safe as they can be) using a custom nested version of `jsonb_set` (`jsonb_nested_set`)
+
+**Requirements:**
+
+- PostgreSQL (>= 12)
+- Rails 6.0.3.2
+
+## Usage
+
+### Jsonb Associations
+
+
+### jsonb_set based hash updates
+
+When enabled, *only* keys present in the updated hash and with values changed in memory will be updated.
+To completely delete a key, value pair from an enabled attribute, set the key's value to `nil`.
+
+e.g.
+```ruby
+# given: instance#data == { "key_1"=>1,
+#                           "key_2"=>2,
+#                           "key_3"=> { "key_4"=>7,
+#                                       "key_5"=>8,
+#                                       "key_6"=>9 } }
+
+instance.update({ key_1: "asdf", a: 1, key_2: nil, key_3: { key_5: nil }})
+# instance#data => { "key_1"=>"asdf",
+#                    "a"=>"asdf",
+#                    "key_3"=> { "key_4"=>7,
+#                                "key_6"=>9 } }
+
+```
+
+#### enabling/adding attribute types
+first, create the sql function
+```bash
+rails g migration add_jsonb_nested_set_function
+```
+```ruby
+class CreateState < ActiveRecord::Migration[6.0]
+  def up
+    add_jsonb_nested_set_function
+  end
+end
+```
+
+then in an initializer, enable key based updates:
+```ruby
+# config/initializers/associate_jsonb.rb
+AssociateJsonb.enable_jsonb_set
+```
+
+Key based updates rely on inheritance for allowed attribute types. Any attributes that respond true to `attr_type.is_a?(GivenClass)` for any enabled type classes will use `jsonb_nested_set`
+
+To add classes to the enabled list, pass them as arguments to `AssociateJsonb.add_hash_type(*klasses)`. Any arguments passed to `AssociateJsonb.enable_jsonb_set` are forwarded to `AssociateJsonb.add_hash_type`
+
+By default, calling `AssociateJsonb.enable_jsonb_set(*klasses)` without arguments, and no classes previously added, adds `ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb` to the allowed classes list
+
+#### disabling/removing attribute types
+by default `jsonb_nested_set` updates are disabled.
+
+if you've enabled them and need to disable, use: `AssociateJsonb.disable_jsonb_set`
+
+To remove a class from the allowed list while leaving nested set updates enabled, use `AssociateJsonb.remove_hash_type(*klasses)`.
+Any arguments passed to `AssociateJsonb.disable_jsonb_set` are forwarded to `AssociateJsonb.remove_hash_type`
+
+### Automatically delete nil value hash keys
+
+When jsonb_set updates are disabled, jsonb columns are replaced with the current document (i.e. default rails behavior)
+
+You are also given the option to automatically clear nil/null values from the hash automatically
+
+in an initializer, enable stripping nil values:
+```ruby
+# config/initializers/associate_jsonb.rb
+AssociateJsonb.jsonb_delete_nil = true
+```
+
+Rules for classes to with this applies are the same as for `jsonb_nested_set`; add and remove classes through `AssociateJsonb.(add|remove)_hash_type(*klasses)`
 
 <!-- This gem was created as a solution to this [task](http://cultofmartians.com/tasks/active-record-jsonb-associations.html) from [EvilMartians](http://evilmartians.com).
 

data/lib/associate_jsonb.rb

@@ -12,21 +12,106 @@ require "mutex_m"
 
 require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "postgresql" => "PostgreSQL",
+  "supported_rails_version" => "SUPPORTED_RAILS_VERSION"
+)
+loader.collapse("#{__dir__}/associate_jsonb/connection_adapters/schema_definitions")
 loader.setup # ready!
 
 module AssociateJsonb
+  mattr_accessor :jsonb_hash_types, default: []
+  mattr_accessor :jsonb_set_removed, default: []
+  mattr_accessor :jsonb_set_enabled, default: false
+  mattr_accessor :jsonb_delete_nil, default: false
+  private_class_method :jsonb_hash_types=
+  private_class_method :jsonb_set_enabled=
+
+  def self.enable_jsonb_set(klass = nil, *classes)
+    add_hash_type(*Array(klass), *classes) unless klass.nil?
+    self.jsonb_set_enabled = true
+  end
+
+  def self.disable_jsonb_set(klass = nil, *classes)
+    remove_hash_type(*Array(klass), *classes) unless klass.nil?
+    self.jsonb_set_enabled = false
+  end
+
+  def self.add_hash_type(*classes)
+    self.jsonb_hash_types |= classes.flatten
+  end
+
+  def self.remove_hash_type(*classes)
+    self.jsonb_set_removed |= classes.flatten
+  end
+
+  def self.merge_hash?(v)
+    return false unless jsonb_set_enabled && v
+    self.jsonb_hash_types.any? { |type| v.is_a?(type) }
+  end
+
+  def self.is_hash?(v)
+    self.jsonb_hash_types.any? { |type| v.is_a?(type) }
+  end
 end
 
 
 # rubocop:disable Metrics/BlockLength
 ActiveSupport.on_load :active_record do
   loader.eager_load
+  AssociateJsonb.class_eval do
+    def self.enable_jsonb_set(klass = nil, *classes)
+      if klass.nil?
+        add_hash_type ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb if jsonb_hash_types.empty?
+      else
+        add_hash_type |= [*Array(klass), *classes].flatten
+      end
+      self.jsonb_set_enabled = true
+    end
+
+    self.enable_jsonb_set if jsonb_set_enabled
+
+    def self.remove_hash_type(*classes)
+      self.jsonb_hash_types -= classes.flatten
+    end
+    removed = jsonb_set_removed
+    self.remove_hash_type removed
+    self.send :remove_method, :jsonb_set_removed
+    self.send :remove_method, :jsonb_set_removed=
+  end
+
 
   ActiveRecord::Base.include AssociateJsonb::WithStoreAttribute
   ActiveRecord::Base.include AssociateJsonb::Associations
+  ActiveRecord::Base.include AssociateJsonb::AttributeMethods
+  ActiveRecord::Base.include AssociateJsonb::Persistence
 
   Arel::Nodes.include AssociateJsonb::ArelNodes
-  Arel::Nodes::Binary.include AssociateJsonb::ArelNodeExtensions::Binary
+
+  Arel::Nodes::Binary.prepend(
+    AssociateJsonb::ArelExtensions::Nodes::Binary
+  )
+
+  Arel::Nodes::TableAlias.prepend(
+    AssociateJsonb::ArelExtensions::Nodes::TableAlias
+  )
+
+  Arel::Table.prepend(
+    AssociateJsonb::ArelExtensions::Table
+  )
+
+  Arel::Visitors::PostgreSQL.prepend(
+    AssociateJsonb::ArelExtensions::Visitors::PostgreSQL
+  )
+
+  Arel::Visitors::Visitor.singleton_class.prepend(
+    AssociateJsonb::ArelExtensions::Visitors::Visitor
+  )
+
+
+  ActiveRecord::Associations::AliasTracker.prepend(
+    AssociateJsonb::Associations::AliasTracker
+  )
 
   ActiveRecord::Associations::Builder::BelongsTo.extend(
     AssociateJsonb::Associations::Builder::BelongsTo
@@ -63,8 +148,33 @@ ActiveSupport.on_load :active_record do
   # ActiveRecord::Associations::Preloader::HasMany.prepend(
   #   AssociateJsonb::Associations::Preloader::HasMany
   # )
+  %i[
+    AlterTable
+    ConstraintDefinition
+    ReferenceDefinition
+    SchemaCreation
+    Table
+    TableDefinition
+  ].each do |m|
+    includable = AssociateJsonb::ConnectionAdapters.const_get(m)
+    including =
+      begin
+        ActiveRecord::ConnectionAdapters::PostgreSQL.const_get(m)
+      rescue NameError
+        ActiveRecord::ConnectionAdapters.const_get(m)
+      end
+    including.prepend includable
+  rescue NameError
+    ActiveRecord::ConnectionAdapters::PostgreSQL.const_set(m, includable)
+  end
+
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(
+    AssociateJsonb::ConnectionAdapters::SchemaStatements
+  )
+
 
   ActiveRecord::Reflection::AbstractReflection.prepend AssociateJsonb::Reflection
+  ActiveRecord::PredicateBuilder.prepend AssociateJsonb::PredicateBuilder
   ActiveRecord::Relation::WhereClause.prepend AssociateJsonb::Relation::WhereClause
 
   ActiveRecord::ConnectionAdapters::ReferenceDefinition.prepend(

data/lib/associate_jsonb/arel_extensions/nodes/binary.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelExtensions
+    module Nodes
+      module Binary
+        def original_left
+          left
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_extensions/nodes/table_alias.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelExtensions
+    module Nodes
+      module TableAlias
+        attr_reader :store_tracker
+
+        def initialize(*args, store_columns: nil)
+          @store_columns = store_columns
+          super(*args)
+        end
+
+        def with_store_tracker(tracker)
+          @store_tracker = tracker
+          self
+        end
+
+        def [](name)
+          return super unless store_col = store_tracker&.get(name)
+
+          attr = ::Arel::Nodes::Jsonb::DashArrow.
+            new(self, self[store_col[:store]], store_col[:key])
+
+          if cast_as = (store_col[:cast] && store_col[:cast][:sql_type])
+            attr = ::Arel::Nodes::NamedFunction.new(
+              "CAST",
+              [ attr.as(cast_as) ]
+            )
+          end
+
+          Arel::Nodes::Jsonb::Attribute.new(self, name, attr)
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_extensions/table.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelExtensions
+    module Table
+      attr_reader :store_tracker
+
+      def initialize(*args, store_tracker: nil, **opts)
+        @store_tracker = store_tracker
+        super(*args, **opts)
+      end
+
+      def alias(...)
+        super(...).with_store_tracker(store_tracker)
+      end
+
+      def with_store_tracker(tracker)
+        @store_tracker = tracker
+        self
+      end
+
+      def [](name)
+        return super unless store_col = store_tracker&.get(name)
+
+        attr = ::Arel::Nodes::Jsonb::DashDoubleArrow.
+          new(self, self[store_col[:store]], store_col[:key])
+
+        if cast_as = (store_col[:cast] && store_col[:cast][:sql_type])
+          attr = ::Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [ attr.as(cast_as) ]
+          )
+        end
+
+        Arel::Nodes::Jsonb::Attribute.new(self, name, attr)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_extensions/visitors/postgresql.rb

@@ -0,0 +1,113 @@
+module AssociateJsonb
+  module ArelExtensions
+    module Visitors
+      module PostgreSQL
+        private
+          def collect_hash_changes(original, updated, nesting = nil)
+            keys = original.keys.map(&:to_s)
+            updated_keys = updated.keys.map(&:to_s)
+            keys |= updated_keys
+            original = original.with_indifferent_access
+            updated = updated.with_indifferent_access
+            added = []
+            deleted = []
+            finished = {}
+            keys.each do |k|
+              if updated[k].is_a?(Hash)
+                finished[k], a, d = collect_hash_changes(original[k].is_a?(Hash) ? original[k] : {}, updated[k], nesting ? "#{nesting},#{k}" : k)
+                a = [[(nesting ? "{#{nesting},#{k}}" : "{#{k}}"), {}]] if original[k].nil? && a.blank?
+                added |= a
+                deleted |= d
+              elsif updated[k].nil?
+                  deleted << (nesting ? "{#{nesting},#{k}}" : "{#{k}}") if updated_keys.include?(k)
+              elsif original[k] != updated[k]
+                finished[k] = updated[k]
+                added << [(nesting ? "{#{nesting},#{k}}" : "{#{k}}"), updated[k]]
+              end
+            end
+            [ finished, added, deleted ]
+          end
+
+          def is_hash?(type)
+            AssociateJsonb.is_hash? type
+          end
+
+          def is_update?(collector)
+            collector &&
+              Array(collector.value).any? {|v| v.is_a?(String) && (v =~ /UPDATE/) }
+          rescue
+            false
+          end
+
+          def is_insert?(collector)
+            collector &&
+              Array(collector.value).any? {|v| v.is_a?(String) && (v =~ /INSERT INTO/) }
+          rescue
+            false
+          end
+
+          def visit_BindHashChanges(t, collector)
+            changes, additions, deletions =
+              collect_hash_changes(
+                t.original_value.presence || {},
+                t.value.presence || {}
+              )
+
+            base_json = +"COALESCE(#{quote_column_name(t.name)}, '{}'::jsonb)"
+            json = base_json
+
+            deletions.each do |del|
+              json = +"(#{json} #- '#{del}')"
+            end
+
+            coalesced_paths = []
+            additions.sort.each do |add, value|
+              collector.add_bind(t.with_value_from_user(value)) do |i|
+                json = +"jsonb_nested_set(#{json},'#{add}', COALESCE($#{i}, '{}'::jsonb))"
+                ''
+              end
+            end
+
+            collector << json
+          end
+
+          def visit_Arel_Nodes_BindParam(o, collector)
+            catch(:nodes_bound) do
+              if AssociateJsonb.jsonb_set_enabled
+                catch(:not_hashable) do
+                  if is_hash?(o.value.type)
+                    if is_update?(collector)
+                      visit_BindHashChanges(o.value, collector)
+
+                      throw :nodes_bound, collector
+                    elsif is_insert?(collector)
+                      value = o.value
+
+                      value, _, _ =
+                        collect_hash_changes(
+                          {},
+                          value.value.presence || {}
+                        )
+                      throw :nodes_bound, collector.add_bind(o.value.with_cast_value(value)) { |i| "$#{i}"}
+                    else
+                      throw :not_hashable
+                    end
+                  else
+                    throw :not_hashable
+                  end
+                end
+              elsif AssociateJsonb.jsonb_delete_nil && is_hash?(o.value.type)
+                value, _, _ =
+                  collect_hash_changes(
+                    {},
+                    o.value.value.presence || {}
+                  )
+                throw :nodes_bound, collector.add_bind(o.value.with_cast_value(value)) { |i| "$#{i}" }
+              end
+              throw :nodes_bound, collector.add_bind(o.value) { |i| "$#{i}" }
+            end
+          end
+      end
+    end
+  end
+end