associate_jsonb 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2488f59e2d11f0055e7bf0f619397eb949517e61110d8e5b5a81409231f6f6fe
-  data.tar.gz: dbebbe5383f20bdb95e359210df22161eecf1819d0148bede5e587b4a62b3f7b
+  metadata.gz: f0832e64c43e22ba206a98d0603c0e231c1606b17315f715a4050e19a1fdb21b
+  data.tar.gz: ff37b2777adf131f20ad9a95076d8797ecf30dc2ddeaa86913de5a457cf9fed4
 SHA512:
-  metadata.gz: db5297d3d3557fef9ca21a7aceaebc13788006e3e1597156cfc108308ce902af258435b9c820bad6a9df88735f8f778774ad4fe198e6189067ae223dd0cf4ab4
-  data.tar.gz: 8bf8a3a056de12214579f8ca8a8cf0a471bde370f531abd86da7d239802ccdb673e058484f4998d6fc0aec2082932b07431013cb222361e4af3c696f1bb8dc81
+  metadata.gz: 00fbd32bc9e66fa8bd85fcf9cab51850bc65443a99f66dbc3bcff5ca5d05e855624c62ac9a0aa7bcbed330a2650dbe149806c49bc3bb40ecd3aa6cdf002fde19
+  data.tar.gz: b134266f93576482f3558be28840081b803982ce369bd75497af2d9d2d2db30e3c27364247485ef2a4712705fb01183d80b812f6fa28f18d8f7db37db555bb88

data/README.md

@@ -4,7 +4,85 @@
 
 #### 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`
+  - 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

@@ -16,18 +16,70 @@ 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 :safe_hash_classes, default: [
-    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb
-  ]
+  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
@@ -96,6 +148,30 @@ 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

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

@@ -13,58 +13,98 @@ module AssociateJsonb
             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)
+              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
-              else
-                if updated[k].nil?
+              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
+              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_update?(o, collector)
+          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/) } &&
-              AssociateJsonb.safe_hash_classes.any? {|t| o.value.type.is_a?(t) }
+              Array(collector.value).any? {|v| v.is_a?(String) && (v =~ /UPDATE/) }
           rescue
             false
           end
 
-          def visit_Arel_Nodes_BindParam(o, collector)
-            if is_hash_update?(o, collector)
-              value = o.value
+          def is_insert?(collector)
+            collector &&
+              Array(collector.value).any? {|v| v.is_a?(String) && (v =~ /INSERT INTO/) }
+          rescue
+            false
+          end
 
-              changes, additions, deletions =
-                collect_hash_changes(
-                  value.original_value.presence || {},
-                  value.value.presence || {}
-                )
+          def visit_BindHashChanges(t, collector)
+            changes, additions, deletions =
+              collect_hash_changes(
+                t.original_value.presence || {},
+                t.value.presence || {}
+              )
 
-              json = +"COALESCE(#{quote_column_name(o.value.name)}, '{}'::jsonb)"
+            base_json = +"COALESCE(#{quote_column_name(t.name)}, '{}'::jsonb)"
+            json = base_json
 
-              deletions.each do |del|
-                json = +"(#{json} #- '#{del}')"
-              end
+            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
+            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
+            collector << json
+          end
 
-              collector
-            else
-              collector.add_bind(o.value) { |i| "$#{i}" }
+          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

data/lib/associate_jsonb/associations/builder/belongs_to.rb

@@ -22,7 +22,7 @@ module AssociateJsonb
           key = (reflection.jsonb_store_key || foreign_key).to_s
           store = reflection.jsonb_store_attr
 
-          mixin.instance_eval <<-CODE, __FILE__, __LINE__ + 1
+          mixin.instance_eval <<~CODE, __FILE__, __LINE__ + 1
             if attribute_names.include?(foreign_key)
               raise AssociateJsonb::Associations::
                       ConflictingAssociation,
@@ -51,7 +51,7 @@ module AssociateJsonb
             foreign_type = :integer
           end
 
-          mixin.instance_eval <<-CODE, __FILE__, __LINE__ + 1
+          mixin.instance_eval <<~CODE, __FILE__, __LINE__ + 1
             store_column_attribute(:#{store}, :#{foreign_key}, foreign_type, sql_type: sql_type, key: "#{key}", **opts)
           CODE
         end

data/lib/associate_jsonb/connection_adapters/schema_creation.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 # frozen_string_literal: true
 
 module AssociateJsonb
@@ -8,55 +9,153 @@ module AssociateJsonb
           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)
+          sql
         end
 
-        def visit_TableDefinition(...)
-          add_jsonb_function(o, super(...))
+        def visit_TableDefinition(o)
+          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
+          create_sql << "IF NOT EXISTS " if o.if_not_exists
+          create_sql << "#{quote_table_name(o.name)} "
+
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
+
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
+          end
+
+          if supports_foreign_keys?
+            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+            # statements.concat(o.constraints.map { |ct| visit_ConstraintDefinition(ct) })
+          end
+
+          create_sql << "(#{statements.join(', ')})" if statements.present?
+          add_table_options!(create_sql, table_options(o))
+          create_sql << " AS #{to_sql(o.as)}" if o.as
+          create_sql
         end
 
-        def visit_ColumnDefinition(o)
-          column_sql = super
-          add_column_constraint!(o, column_sql, column_options(o))
-          column_sql
+        def visit_ConstraintDeferral(o)
+          return "" unless o.deferrable_default?
+          return "NOT DEFERRABLE" unless o.deferrable?
+          initial =
+            case o.deferrable
+            when :immediate
+              "IMMEDIATE"
+            else
+              "DEFERRED"
+            end
+          "DEFERRABLE INITIALLY #{initial}"
         end
 
         def visit_ConstraintDefinition(o)
           +<<-SQL.squish
-            CONSTRAINT #{o.name} CHECK (#{o.value})
+            CONSTRAINT #{quote_column_name(o.name)}
+            CHECK (#{o.value})
+              #{visit_ConstraintDeferral(o)}
+              #{o.not_valid? ? "NOT VALID" : ''}
           SQL
         end
 
         def visit_AddConstraint(o)
-          "ADD #{accept(o)}"
+          sql = +""
+          if o.force?
+            sql << visit_DropConstraint(o)
+            sql << " "
+          end
+          sql << "ADD #{accept(o)}"
         end
 
-        def visit_DropConstraint(o)
-          "DROP CONSTRAINT #{o.name}"
+        def visit_DropConstraint(o, if_exists: false)
+          +<<-SQL.squish
+            DROP CONSTRAINT #{quote_column_name(o.name)}
+              #{o.force? ? "IF EXISTS" : ""}
+          SQL
         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
+        def visit_AddJsonbForeignKeyFunction(*)
+          <<~SQL
+            CREATE OR REPLACE FUNCTION jsonb_foreign_key
+              (
+                table_name text,
+                foreign_key text,
+                store jsonb,
+                key text,
+                type text default 'numeric',
+                nullable boolean default TRUE
+              )
+            RETURNS BOOLEAN AS
+            $BODY$
+            DECLARE
+              does_exist BOOLEAN;
+            BEGIN
+              IF store->key IS NULL
+              THEN
+                return nullable;
+              END IF;
 
-          sql
+              EXECUTE FORMAT('SELECT EXISTS (SELECT 1 FROM %1$I WHERE %1$I.%2$I = CAST($1 AS ' || type || '))', table_name, foreign_key)
+              INTO does_exist
+              USING store->>key;
+
+              RETURN does_exist;
+            END;
+            $BODY$
+            LANGUAGE plpgsql;
+
+          SQL
         end
 
-        def add_jsonb_function(o, sql)
-          if sql =~ /jsonb_foreign_key/
-            visit_AddJsonForeignKeyFunction(o) + sql
-          else
-            sql
+        def visit_AddJsonbNestedSetFunction(*)
+          <<~SQL
+            CREATE OR REPLACE FUNCTION jsonb_nested_set
+              (
+                target jsonb,
+                path text[],
+                new_value jsonb
+              )
+            RETURNS jsonb AS
+            $BODY$
+            DECLARE
+              new_json jsonb := '{}'::jsonb;
+              does_exist BOOLEAN;
+              current_path text[];
+              key text;
+            BEGIN
+              IF target #> path IS NOT NULL
+              THEN
+                return jsonb_set(target, path, new_value);
+              ELSE
+                new_json := target;
+
+                IF array_length(path, 1) > 1
+                THEN
+                  FOREACH key IN ARRAY path[:(array_length(path, 1) - 1)]
+                  LOOP
+                    current_path := array_append(current_path, key);
+                    IF new_json #> current_path IS NULL
+                    THEN
+                      new_json := jsonb_set(new_json, current_path, '{}'::jsonb, TRUE);
+                    END IF;
+                  END LOOP;
+                END IF;
+
+                return jsonb_set(new_json, path, new_value, TRUE);
+              END IF;
+            END;
+            $BODY$
+            LANGUAGE plpgsql;
+          SQL
+        end
+
+        def add_column_options!(sql, opts)
+          super
+
+          if opts[:constraint]
+            sql << " #{accept(ConstraintDefinition.new(**opts[:constraint]))}"
           end
+
+          sql
         end
     end
   end

data/lib/associate_jsonb/connection_adapters/schema_definitions/add_jsonb_foreign_key_function.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    class AddJsonbForeignKeyFunction
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/{table_definition.rb → schema_definitions/add_jsonb_nested_set_function.rb}

@@ -1,9 +1,9 @@
+# encoding: utf-8
 # frozen_string_literal: true
 
 module AssociateJsonb
   module ConnectionAdapters
-    module TableDefinition #:nodoc:
-      
+    class AddJsonbNestedSetFunction
     end
   end
 end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module AlterTable # :nodoc:
+      attr_reader :constraint_adds, :constraint_drops
+      def initialize(td)
+        super
+        @constraint_adds = []
+        @constraint_drops = []
+      end
+
+      def add_constraint(name = nil, **opts)
+        unless opts[:value].present?
+          raise ArgumentError.new("Invalid Add Constraint Options")
+        end
+
+        @constraint_adds << ConstraintDefinition.new(
+          **opts.reverse_merge(name: name)
+        )
+      end
+
+      def alter_constraint(name = nil, **opts)
+        opts[:force] = true
+        add_constraint(name, **opts)
+      end
+
+      def drop_constraint(name = nil, **opts)
+        opts = opts.reverse_merge(force: true, name: name, value: nil)
+
+        unless opts[:name].present? || opts[:value].present?
+          raise ArgumentError.new("Invalid Drop Constraint Options")
+        end
+
+        @constraint_drops << ConstraintDefinition.new(**opts)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/constraint_definition.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    class ConstraintDefinition
+      # rubocop:disable Metrics/ParameterLists
+      attr_reader :name, :value, :not_valid, :deferrable, :force
+      def initialize(value:, name: nil, not_valid: false, force: false, deferrable: true, **)
+        @name = name.presence
+        @value = value
+        @not_valid = not_valid
+        @deferrable = deferrable
+        @force = force
+
+        @name ||=
+          "rails_constraint_" \
+          "#{@value.hash}" \
+          "_#{not_valid ? "nv" : "v"}" \
+          "_#{deferrable ? "d" : "nd"}"
+      end
+
+      def deferrable_default?
+        deferrable.nil?
+      end
+
+
+      def name?
+        !!name
+      end
+
+      def value?
+        !!value
+      end
+
+      def not_valid?
+        !!not_valid
+      end
+
+      def deferrable?
+        !!deferrable
+      end
+
+      def force?
+        !!force
+      end
+
+      def to_h
+        {
+          name: name,
+          value: value,
+          not_valid: not_valid,
+          deferrable: deferrable,
+          force: force
+        }
+      end
+      alias :to_hash :to_h
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/{reference_definition.rb → schema_definitions/reference_definition.rb}

@@ -1,8 +1,9 @@
+# encoding: utf-8
 # frozen_string_literal: true
 
 module AssociateJsonb
   module ConnectionAdapters
-    module ReferenceDefinition #:nodoc:
+    module ReferenceDefinition
       ForeignKeyDefinition = ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
       # rubocop:disable Metrics/ParameterLists
       def initialize(
@@ -13,6 +14,7 @@ module AssociateJsonb
       )
         @store = store && store.to_sym
         @store_key = store_key && store_key.to_s unless options[:polymorphic]
+        @nullable = options[:null] != false
 
         super(name, **options)
       end
@@ -39,20 +41,24 @@ module AssociateJsonb
 
         if foreign_key && column_names.length == 1
           fk = ForeignKeyDefinition.new(table.name, foreign_table_name, foreign_key_options)
-          columns.each do |col_name, type, _|
+          columns.each do |col_name, type, options|
+            options ||= {}
             value = <<-SQL.squish
               jsonb_foreign_key(
-                '#{fk.to_table}',
-                '#{fk.active_record_primary_key}',
-                #{store},
-                '#{col_name}',
-                '#{type}'
+                '#{fk.to_table}'::text,
+                '#{fk.primary_key}'::text,
+                #{store}::jsonb,
+                '#{col_name}'::text,
+                '#{type}'::text,
+                #{nullable}
               )
             SQL
-            table.constraint({
+            table.constraint(
               name: "#{table.name}_#{col_name}_foreign_key",
-              value: value
-            })
+              value: value,
+              not_valid: true,
+              deferrable: true
+            )
           end
         end
 
@@ -76,7 +82,7 @@ module AssociateJsonb
 
       protected
 
-      attr_reader :store, :store_key
+      attr_reader :store, :store_key, :nullable
     end
   end
 end

data/lib/associate_jsonb/connection_adapters/schema_definitions/table.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module Table
+      def constraint(**opts)
+        @base.add_constraint(name, **opts)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/table_definition.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module TableDefinition
+      attr_reader :constraints
+
+      def initialize(*,**)
+        super
+        @constraints = []
+      end
+
+      def constraint(name = nil, **opts)
+        unless opts[:value].present?
+          raise ArgumentError.new("Invalid Drop Constraint Options")
+        end
+
+        @constraints << ConstraintDefinition.new(
+          **opts.reverse_merge(name: name)
+        )
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_statements.rb

@@ -1,13 +1,116 @@
+# encoding: utf-8
 # 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
+      def add_jsonb_nested_set_function
+        execute schema_creation.accept(AddJsonbNestedSetFunction.new)
+      end
+
+      def add_jsonb_foreign_key_function
+        execute schema_creation.accept(AddJsonbForeignKeyFunction.new)
+      end
+
+      def create_table(table_name, **options)
+        td = create_table_definition(table_name, **options)
+
+        if options[:id] != false && !options[:as]
+          pk = options.fetch(:primary_key) do
+            ActiveRecord::Base.get_primary_key table_name.to_s.singularize
+          end
+
+          if pk.is_a?(Array)
+            td.primary_keys pk
+          else
+            td.primary_key pk, options.fetch(:id, :primary_key), **options.except(:comment)
+          end
+        end
+
+        yield td if block_given?
+
+        if options[:force]
+          drop_table(table_name, **options, if_exists: true)
+        end
+
+        result = execute schema_creation.accept td
+
+        td.indexes.each do |column_name, index_options|
+          add_index(table_name, column_name, index_options)
+        end
+
+        td.constraints.each do |ct|
+          add_constraint(table_name, **ct)
+        end
+
+        if table_comment = options[:comment].presence
+          change_table_comment(table_name, table_comment)
+        end
+
+        td.columns.each do |column|
+          change_column_comment(table_name, column.name, column.comment) if column.comment.present?
+        end
+
+        result
+      end
+
+      def add_constraint(table_name, **options)
+        at = create_alter_table table_name
+        at.add_constraint(**options)
+        execute schema_creation.accept at
+      end
+
+      def constraints(table_name) # :nodoc:
+        scope = quoted_scope(table_name)
+
+        result = query(<<~SQL, "SCHEMA")
+          SELECT
+            con.oid,
+            con.conname,
+            con.connamespace,
+            con.contype,
+            con.condeferrable,
+            con.condeferred,
+            con.convalidated,
+            pg_get_constraintdef(con.oid) as consrc
+          FROM pg_catalog.pg_constraint con
+          INNER JOIN pg_catalog.pg_class rel
+                     ON rel.oid = con.conrelid
+          INNER JOIN pg_catalog.pg_namespace nsp
+                     ON nsp.oid = connamespace
+          WHERE nsp.nspname = #{scope[:schema]}
+          AND rel.relname = #{scope[:name]}
+          ORDER BY rel.relname
+        SQL
+
+        result.map do |row|
+          {
+            oid: row[0],
+            name: row[1],
+            deferrable: row[4],
+            deferred: row[5],
+            validated: row[6],
+            definition: row[7],
+            type:
+              case row[3].to_s.downcase
+              when "c"
+                "CHECK"
+              when "f"
+                "FOREIGN KEY"
+              when "p"
+                "PRIMARY KEY"
+              when "u"
+                "UNIQUE"
+              when "t"
+                "TRIGGER"
+              when "x"
+                "EXCLUDE"
+              else
+                "UNKNOWN"
+              end
+          }
+        end
+      end
     end
   end
 end

data/lib/associate_jsonb/version.rb

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

data/lib/associate_jsonb/with_store_attribute.rb

@@ -34,7 +34,7 @@ module AssociateJsonb
     end
 
     included do
-      instance_eval <<-CODE, __FILE__, __LINE__ + 1
+      instance_eval <<~CODE, __FILE__, __LINE__ + 1
         initialize_store_column_attribute_tracker
 
         after_initialize &set_store_column_attribute_values_on_init
@@ -106,7 +106,7 @@ module AssociateJsonb
         array = attribute_opts[:array]
         attribute attr, cast_type, **attribute_opts
 
-        instance_eval <<-CODE, __FILE__, __LINE__ + 1
+        instance_eval <<~CODE, __FILE__, __LINE__ + 1
           add_store_column_attribute_name("#{attr}", :#{store}, "#{key}", { sql_type: sql_type, type: cast_type, opts: attribute_opts })
         CODE
 
@@ -117,47 +117,52 @@ module AssociateJsonb
     class InstanceMethodsOnActivation < Module
       def initialize(mixin, store, attribute, key, is_array)
         is_array = !!(is_array && attribute.to_s =~ /_ids$/)
-        on_attr_change =
-           is_array \
-            ? "write_attribute(:#{attribute}, Array(given))" \
-            : "super(given)"
-        on_store_change = ->(var) {
-          "write_attribute(:#{attribute}, #{
-            is_array \
-             ? "Array(#{var})" \
-             : var
-          })"
-        }
 
+        array_or_attr = ->(value) {
+          is_array \
+           ? %Q(Array(#{value})) \
+           : %Q(#{value})
+         }
+
+        on_store_change = "_write_attribute(:#{attribute}, #{array_or_attr.call %Q(#{store}["#{key}"])})"
+        on_attr_change = "super(#{array_or_attr.call %Q(given)})"
 
         if is_array
-          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          mixin.class_eval <<~CODE, __FILE__, __LINE__ + 1
             def #{attribute}
               _read_attribute(:#{attribute}) || []
             end
           CODE
         end
 
-        mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        mixin.class_eval <<~CODE, __FILE__, __LINE__ + 1
           def #{store}=(given)
-            if !given
-              given = {}
-              #{store}.keys.each do |k|
-                given[k] = nil
-              end
+            if given.is_a?(::String)
+              given = ActiveSupport::JSON.decode(given) rescue nil
             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
+
+            if AssociateJsonb.merge_hash?(self.class.attribute_types["#{store}"])
+              if !given
+                given = {}
+                #{store}.keys.each do |k|
+                  given[k] = nil
+                end
+              end
+              super(#{store}.deep_merge(given.deep_stringify_keys))
+
+              self.#{attribute}= #{store}["#{key}"] if #{store}.key?("#{key}")
+            else
+              super given || {}
+              self.#{attribute}= #{store}["#{key}"]
             end
+
             #{store}
           end
 
           def #{attribute}=(given)
             #{on_attr_change}
             value = #{store}["#{key}"] = #{attribute}.presence
-            _write_attribute(:#{store}, #{store})
+            #{store}.delete("#{key}") unless !value.nil? || AssociateJsonb.merge_hash?(self.class.attribute_types["#{store}"])
             value
           end
         CODE

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: associate_jsonb
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Sampson Crowley
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-21 00:00:00.000000000 Z
+date: 2020-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -104,14 +104,18 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.7.0
-description: |2
-      This gem extends ActiveRecord to let you use PostgreSQL JSONB data for associations
+description: |
+  This gem extends ActiveRecord to add additional functionality to JSONB
 
-      Inspired by activerecord-jsonb-associations, but for use in Rails 6+ and
-      ruby 2.7+ and with some unnecessary options and features (HABTM) removed
+  - use PostgreSQL JSONB data for associations
+  - thread-safe single-key updates to JSONB columns using `jsonb_set`
+  - extended `table#references` for easy migrations and indexes
+  - virtual JSONB foreign keys using check constraints
+    (NOTE: real foreign key constraints are not possible with PostgreSQL JSONB)
 
-      BONUS: extended `table#references` for easy migrations and indexes
-      (NOTE: real foreign key constraints are not possible with PostgreSQL JSONB)
+  Inspired by activerecord-jsonb-associations, but for use in Rails 6+ and
+  ruby 2.7+ and with some unnecessary options and features (HABTM) removed
+  and some additional features added
 email:
 - sampsonsprojects@gmail.com
 executables: []
@@ -151,11 +155,15 @@ files:
 - 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_definitions/add_jsonb_foreign_key_function.rb
+- lib/associate_jsonb/connection_adapters/schema_definitions/add_jsonb_nested_set_function.rb
+- lib/associate_jsonb/connection_adapters/schema_definitions/alter_table.rb
+- lib/associate_jsonb/connection_adapters/schema_definitions/constraint_definition.rb
+- lib/associate_jsonb/connection_adapters/schema_definitions/reference_definition.rb
+- lib/associate_jsonb/connection_adapters/schema_definitions/table.rb
+- lib/associate_jsonb/connection_adapters/schema_definitions/table_definition.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

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

@@ -1,35 +0,0 @@
-# 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