associate_jsonb 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cb22feba951a6241ccada849b6d17ae06a4a84c797a49ae139844917d50474c
-  data.tar.gz: 910b39ddc0f89d8525439d9d4e74244a62bbf3f4d07cb333306879312588dfda
+  metadata.gz: 2488f59e2d11f0055e7bf0f619397eb949517e61110d8e5b5a81409231f6f6fe
+  data.tar.gz: dbebbe5383f20bdb95e359210df22161eecf1819d0148bede5e587b4a62b3f7b
 SHA512:
-  metadata.gz: 5382c87315fbbbc8bc52ebb5efb605e60373c7f24e9d681a008f5d5c53dc26649df89f7233ca1b3b6962fdd16a891c9072e55577a3c40e655faa54f3ec0dc375
-  data.tar.gz: 3570c685cde53a273f70f5d434d1daacbc32b260b0b0500a3e6ef801b18a50fdd007a1970ede0d692a5eee89a87eba46b73ced15019514cfafece65b01c588a8
+  metadata.gz: db5297d3d3557fef9ca21a7aceaebc13788006e3e1597156cfc108308ce902af258435b9c820bad6a9df88735f8f778774ad4fe198e6189067ae223dd0cf4ab4
+  data.tar.gz: 8bf8a3a056de12214579f8ca8a8cf0a471bde370f531abd86da7d239802ccdb673e058484f4998d6fc0aec2082932b07431013cb222361e4af3c696f1bb8dc81

data/README.md

@@ -2,7 +2,9 @@
 
 [![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 `jsonb_set`
 
 <!-- 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,10 +12,16 @@ require "mutex_m"
 
 require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
-loader.inflector.inflect "supported_rails_version" => "SUPPORTED_RAILS_VERSION"
+loader.inflector.inflect(
+  "postgresql" => "PostgreSQL",
+  "supported_rails_version" => "SUPPORTED_RAILS_VERSION"
+)
 loader.setup # ready!
 
 module AssociateJsonb
+  mattr_accessor :safe_hash_classes, default: [
+    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb
+  ]
 end
 
 
@@ -25,6 +31,8 @@ ActiveSupport.on_load :active_record do
 
   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
 
@@ -40,6 +48,10 @@ ActiveSupport.on_load :active_record do
     AssociateJsonb::ArelExtensions::Table
   )
 
+  Arel::Visitors::PostgreSQL.prepend(
+    AssociateJsonb::ArelExtensions::Visitors::PostgreSQL
+  )
+
   Arel::Visitors::Visitor.singleton_class.prepend(
     AssociateJsonb::ArelExtensions::Visitors::Visitor
   )
@@ -86,6 +98,7 @@ ActiveSupport.on_load :active_record do
   # )
 
   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/table.rb

@@ -23,7 +23,7 @@ module AssociateJsonb
       def [](name)
         return super unless store_col = store_tracker&.get(name)
 
-        attr = ::Arel::Nodes::Jsonb::DashArrow.
+        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])

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

@@ -0,0 +1,73 @@
+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 original[k].is_a?(Hash) && updated[k].is_a?(Hash)
+                finished[k], a, d = collect_hash_changes(original[k], updated[k], nesting ? "#{nesting},#{k}" : k)
+                added |= a
+                deleted |= d
+              else
+                if 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
+            end
+            [ finished, added, deleted ]
+          end
+
+          def is_hash_update?(o, collector)
+            collector &&
+              Array(collector.value).any? {|v| v.is_a?(String) && (v =~ /UPDATE/) } &&
+              AssociateJsonb.safe_hash_classes.any? {|t| o.value.type.is_a?(t) }
+          rescue
+            false
+          end
+
+          def visit_Arel_Nodes_BindParam(o, collector)
+            if is_hash_update?(o, collector)
+              value = o.value
+
+              changes, additions, deletions =
+                collect_hash_changes(
+                  value.original_value.presence || {},
+                  value.value.presence || {}
+                )
+
+              json = +"COALESCE(#{quote_column_name(o.value.name)}, '{}'::jsonb)"
+
+              deletions.each do |del|
+                json = +"(#{json} #- '#{del}')"
+              end
+
+              additions.each do |add, value|
+                collector.add_bind(o.value.with_value_from_user(value)) do |i|
+                  json = +"jsonb_set(#{json},'#{add}', $#{i}, true)"
+                  ''
+                end
+              end
+
+              collector << json
+
+              collector
+            else
+              collector.add_bind(o.value) { |i| "$#{i}" }
+            end
+          end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/association_scope.rb

@@ -44,23 +44,21 @@ module AssociateJsonb
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       def apply_jsonb_equality(scope, table, jsonb_column, store_key, foreign_key, value, foreign_klass)
-        sql_type = type = node_klass = nil
+        sql_type = type = nil
         begin
           type = foreign_klass.attribute_types[foreign_key.to_s]
           raise "type not found" unless type.present?
           sql_type = foreign_klass.columns_hash[foreign_key.to_s]
           raise "not a column" unless sql_type.present?
           sql_type = sql_type.sql_type
-          node_klass = Arel::Nodes::Jsonb::DashArrow
         rescue
           type = ActiveModel::Type::String.new
           sql_type = "text"
-          node_klass = Arel::Nodes::Jsonb::DashDoubleArrow
         end
 
         scope.where!(
           Arel::Nodes::SqlCastedEquality.new(
-            node_klass.new(table, table[jsonb_column], store_key),
+            Arel::Nodes::Jsonb::DashDoubleArrow.new(table, table[jsonb_column], store_key),
             sql_type,
             Arel::Nodes::BindParam.new(
               ActiveRecord::Relation::QueryAttribute.new(

data/lib/associate_jsonb/associations/belongs_to_association.rb

@@ -4,14 +4,14 @@
 module AssociateJsonb
   module Associations
     module BelongsToAssociation #:nodoc:
-      def replace_keys(record)
-        return super unless reflection.options.key?(:store)
-
-        owner[reflection.foreign_key] =
-          record._read_attribute(
-            reflection.association_primary_key(record.class)
-          )
-      end
+      # def replace_keys(record)
+      #   return super unless reflection.options.key?(:store)
+      #
+      #   owner[reflection.foreign_key] =
+      #     record._read_attribute(
+      #       reflection.association_primary_key(record.class)
+      #     )
+      # end
     end
   end
 end

data/lib/associate_jsonb/attribute_methods.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module AttributeMethods
+    extend ActiveSupport::Concern
+
+    included do
+      include Read
+    end
+
+    private
+      def attributes_with_info(attribute_names)
+        attribute_names.each_with_object({}) do |name, attrs|
+          attrs[name] = _fetch_attribute(name)
+        end
+      end
+  end
+end

data/lib/associate_jsonb/attribute_methods/read.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      def _fetch_attribute(attr_name, &block) # :nodoc
+        sync_with_transaction_state if @transaction_state&.finalized?
+        @attributes.fetch(attr_name.to_s, &block)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/reference_definition.rb

@@ -3,18 +3,25 @@
 module AssociateJsonb
   module ConnectionAdapters
     module ReferenceDefinition #:nodoc:
+      ForeignKeyDefinition = ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
       # rubocop:disable Metrics/ParameterLists
       def initialize(
         name,
         store: false,
+        store_key: false,
         **options
       )
         @store = store && store.to_sym
+        @store_key = store_key && store_key.to_s unless options[:polymorphic]
 
         super(name, **options)
       end
       # rubocop:enable Metrics/ParameterLists
 
+      def column_name
+        store_key || super
+      end
+
       def add_to(table)
         return super unless store
 
@@ -25,40 +32,51 @@ module AssociateJsonb
           should_add_col = table.columns.none? {|col| col.name.to_sym == store}
         end
 
-        table.column(store, :jsonb, null: false, default: {}) if should_add_col
+        if should_add_col
+          opts = { null: false, default: {} }
+          table.column(store, :jsonb, **opts)
+        end
+
+        if foreign_key && column_names.length == 1
+          fk = ForeignKeyDefinition.new(table.name, foreign_table_name, foreign_key_options)
+          columns.each do |col_name, type, _|
+            value = <<-SQL.squish
+              jsonb_foreign_key(
+                '#{fk.to_table}',
+                '#{fk.active_record_primary_key}',
+                #{store},
+                '#{col_name}',
+                '#{type}'
+              )
+            SQL
+            table.constraint({
+              name: "#{table.name}_#{col_name}_foreign_key",
+              value: value
+            })
+          end
+        end
 
         return unless index
 
-        # should_add_idx = false
-        # if table.respond_to? :index_exists?
-        #   should_add_idx = !table.index_exists?([ store ], using: :gin)
-        # elsif table.respond_to? :indexes
-        #   should_add_idx = table.indexes.none? do |idx, opts|
-        #     (idx == [ store ]) \
-        #     && (opts == { using: :gin })
-        #   end
-        # end
-        #
-        # table.index([ store ], using: :gin) if should_add_idx
-
-        column_names.each do |column_name|
+        columns.each do |col_name, type, opts|
+          type = :text if type == :string
           table.index(
-            "CAST (\"#{store}\"->'#{column_name}' AS #{@type || :bigint})",
+            "CAST (\"#{store}\"->>'#{col_name}' AS #{type || :bigint})",
             using: :btree,
-            name: "index_#{table.name}_on_#{store}_#{column_name}"
+            name: "index_#{table.name}_on_#{store}_#{col_name}"
           )
 
           table.index(
-            "(#{store}->>'#{column_name}')",
+            "(\"#{store}\"->>'#{col_name}')",
             using: :btree,
-            name: "index_#{table.name}_on_#{store}_#{column_name}_text"
+            name: "index_#{table.name}_on_#{store}_#{col_name}_text"
           )
         end
       end
 
       protected
 
-      attr_reader :store
+      attr_reader :store, :store_key
     end
   end
 end

data/lib/associate_jsonb/connection_adapters/schema_creation.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module SchemaCreation
+      private
+        def visit_AlterTable(o)
+          sql = super
+          sql << o.constraint_adds.map {|ct| visit_AddConstraint ct }.join(" ")
+          sql << o.constraint_drops.map {|ct| visit_DropConstraint ct }.join(" ")
+          add_jsonb_function(o, sql)
+        end
+
+        def visit_TableDefinition(...)
+          add_jsonb_function(o, super(...))
+        end
+
+        def visit_ColumnDefinition(o)
+          column_sql = super
+          add_column_constraint!(o, column_sql, column_options(o))
+          column_sql
+        end
+
+        def visit_ConstraintDefinition(o)
+          +<<-SQL.squish
+            CONSTRAINT #{o.name} CHECK (#{o.value})
+          SQL
+        end
+
+        def visit_AddConstraint(o)
+          "ADD #{accept(o)}"
+        end
+
+        def visit_DropConstraint(o)
+          "DROP CONSTRAINT #{o.name}"
+        end
+
+        def add_column_constraint!(o, sql, options)
+          if options[:constraint]
+            name = value = nil
+            if options[:constraint].is_a?(Hash)
+              name = quote_column_name(options[:constraint][:name]).presence
+              value = options[:constraint][:value]
+            else
+              value = options[:constraint]
+            end
+            name ||= quote_column_name("#{o.name}_constraint_#{value.hash}")
+            sql << " CONSTRAINT #{name} CHECK (#{value})"
+          end
+
+          sql
+        end
+
+        def add_jsonb_function(o, sql)
+          if sql =~ /jsonb_foreign_key/
+            visit_AddJsonForeignKeyFunction(o) + sql
+          else
+            sql
+          end
+        end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_creation/alter_table.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module SchemaCreation
+      class AlterTable # :nodoc:
+        attr_reader :constraint_adds
+        attr_reader :constraint_drops
+
+        def initialize(td)
+          super
+          @constraint_adds = []
+          @constraint_drops = []
+        end
+
+
+        def add_foreign_key(to_table, options)
+          @foreign_key_adds << ForeignKeyDefinition.new(name, to_table, options)
+        end
+
+        def drop_foreign_key(name)
+          @foreign_key_drops << name
+        end
+
+        def add_constraint(options)
+          @foreign_key_adds << ConstraintDefinition.new(name, options)
+        end
+
+        def drop_constraint(options)
+          @constraint_drops << ConstraintDefinition.new(name, options)
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_statements.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_record/migration/join_table"
+require "active_support/core_ext/string/access"
+require "active_support/deprecation"
+require "digest/sha2"
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module SchemaStatements
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/table_definition.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module TableDefinition #:nodoc:
+      
+    end
+  end
+end

data/lib/associate_jsonb/persistence.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Persistence
+    private
+      def _update_row(attribute_names, attempted_action = "update")
+        self.class._update_record(
+          attributes_with_info(attribute_names),
+          @primary_key => id_in_database
+        )
+      end
+  end
+end

data/lib/associate_jsonb/predicate_builder.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module PredicateBuilder # :nodoc:
+    def build_bind_attribute(column_name, value)
+      if value.respond_to?(:value_before_type_cast)
+        attr = ActiveRecord::Relation::QueryAttribute.new(column_name.to_s, value.value_before_type_cast, table.type(column_name), value)
+      else
+        attr = ActiveRecord::Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
+      end
+      Arel::Nodes::BindParam.new(attr)
+    end
+  end
+end

data/lib/associate_jsonb/reflection.rb

@@ -60,7 +60,7 @@ module AssociateJsonb
           Arel::Nodes::NamedFunction.new(
             "CAST",
             [
-              Arel::Nodes::Jsonb::DashArrow.
+              Arel::Nodes::Jsonb::DashDoubleArrow.
                 new(table, table[foreign_store_attr], foreign_store_key || key).
                 as(foreign_klass.columns_hash[foreign_key.to_s].sql_type)
             ]
@@ -83,7 +83,7 @@ module AssociateJsonb
           Arel::Nodes::NamedFunction.new(
             "CAST",
             [
-              Arel::Nodes::Jsonb::DashArrow.
+              Arel::Nodes::Jsonb::DashDoubleArrow.
                 new(foreign_table, foreign_table[jsonb_store_attr], jsonb_store_key || foreign_key).
                 as(klass.columns_hash[key.to_s].sql_type)
             ]

data/lib/associate_jsonb/relation/where_clause.rb

@@ -1,3 +1,6 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
 module AssociateJsonb
   module Relation
     module WhereClause

data/lib/associate_jsonb/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module AssociateJsonb
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/associate_jsonb/with_store_attribute.rb

@@ -140,20 +140,23 @@ module AssociateJsonb
 
         mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
           def #{store}=(given)
-            super(given || {})
-            write_attribute(:#{attribute}, #{on_store_change.call %Q(#{store}["#{key}"])})
-            if #{attribute}.blank?
-              #{store}.delete("#{key}")
-            else
-              #{store}["#{key}"] = #{attribute}
+            if !given
+              given = {}
+              #{store}.keys.each do |k|
+                given[k] = nil
+              end
+            end
+            super(#{store}.deep_merge(given.deep_stringify_keys))
+            if #{store}.key?("#{key}")
+              write_attribute(:#{attribute}, #{on_store_change.call %Q(#{store}["#{key}"])})
+              #{store}["#{key}"] = #{attribute}.presence
             end
             #{store}
           end
 
           def #{attribute}=(given)
             #{on_attr_change}
-            value = #{store}["#{key}"] = #{attribute}
-            #{store}.delete("#{key}") if value.nil?
+            value = #{store}["#{key}"] = #{attribute}.presence
             _write_attribute(:#{store}, #{store})
             value
           end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: associate_jsonb
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Sampson Crowley
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-16 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -125,6 +125,7 @@ files:
 - lib/associate_jsonb/arel_extensions/nodes/binary.rb
 - lib/associate_jsonb/arel_extensions/nodes/table_alias.rb
 - lib/associate_jsonb/arel_extensions/table.rb
+- lib/associate_jsonb/arel_extensions/visitors/postgresql.rb
 - lib/associate_jsonb/arel_extensions/visitors/visitor.rb
 - lib/associate_jsonb/arel_nodes/jsonb/at_arrow.rb
 - lib/associate_jsonb/arel_nodes/jsonb/attribute.rb
@@ -147,8 +148,16 @@ files:
 - lib/associate_jsonb/associations/has_many_association.rb
 - lib/associate_jsonb/associations/join_dependency.rb
 - lib/associate_jsonb/associations/preloader/association.rb
+- lib/associate_jsonb/attribute_methods.rb
+- lib/associate_jsonb/attribute_methods/read.rb
 - lib/associate_jsonb/connection_adapters.rb
 - lib/associate_jsonb/connection_adapters/reference_definition.rb
+- lib/associate_jsonb/connection_adapters/schema_creation.rb
+- lib/associate_jsonb/connection_adapters/schema_creation/alter_table.rb
+- lib/associate_jsonb/connection_adapters/schema_statements.rb
+- lib/associate_jsonb/connection_adapters/table_definition.rb
+- lib/associate_jsonb/persistence.rb
+- lib/associate_jsonb/predicate_builder.rb
 - lib/associate_jsonb/reflection.rb
 - lib/associate_jsonb/relation/where_clause.rb
 - lib/associate_jsonb/supported_rails_version.rb