global-registry-bindings 0.0.6 → 0.1.0

data/lib/global_registry_bindings/model/push_relationship.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'global_registry_bindings/workers/push_relationship_worker'
+require 'global_registry_bindings/workers/delete_entity_worker'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Model #:nodoc:
+      module PushRelationship
+        extend ActiveSupport::Concern
+
+        included do
+          after_commit :push_relationships_to_global_registry_async, on: %i[create update]
+          after_commit :delete_relationships_from_global_registry_async, on: %i[destroy]
+        end
+
+        def push_relationships_to_global_registry_async(*types)
+          types = types.empty? ? self.class.global_registry_relationship_types : types
+          types.each do |type|
+            action = global_registry_relationship_change_action(type)
+            send("global_registry_relationship_async_#{action}".to_sym, type)
+          end
+        end
+
+        def delete_relationships_from_global_registry_async(*types)
+          types = types.empty? ? self.class.global_registry_relationship_types : types
+          types.each do |type|
+            next unless global_registry_relationship(type).id_value?
+            ::GlobalRegistry::Bindings::Workers::DeleteEntityWorker.perform_async(
+              global_registry_relationship(type).id_value
+            )
+          end
+        end
+
+        protected
+
+        def global_registry_relationship_async_push(type)
+          ::GlobalRegistry::Bindings::Workers::PushRelationshipWorker.perform_async(self.class, id, type)
+        end
+
+        def global_registry_relationship_async_replace(type)
+          # Replace deletes GR relationship immediately before scheduling an async update
+          ::GlobalRegistry::Bindings::Workers::DeleteEntityWorker.new.perform(
+            global_registry_relationship(type).id_value
+          )
+          ::GlobalRegistry::Bindings::Workers::PushRelationshipWorker.perform_async(self.class, id, type)
+        end
+
+        def global_registry_relationship_async_delete(type)
+          delete_relationships_from_global_registry_async(type)
+        end
+
+        def global_registry_relationship_async_ignore(_type); end # noop
+
+        # rubocop:disable Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize
+        def global_registry_relationship_change_action(type)
+          [global_registry_relationship(type).primary_association_foreign_key,
+           global_registry_relationship(type).related_association_foreign_key].each do |key|
+            if previous_changes.key?(key)
+              # Delete if changed from anything to nil
+              return :delete if previous_changes[key].last.nil?
+              # Replace if value changed
+              return :replace if previous_changes[key].first != previous_changes[key].last &&
+                                 !previous_changes[key].first.nil?
+            elsif key.present? && send(key).nil?
+              # Ignore if value didn't change and foreign_key is nil
+              return :ignore
+            end
+          end
+          # otherwise Create/Update
+          :push
+        end
+        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/model/relationship.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Model #:nodoc:
+      module Relationship
+        extend ActiveSupport::Concern
+
+        def relationship_attributes_to_push(type)
+          entity_attributes = relationship_columns_to_push(type).map do |name, t|
+            relationship_value_for_global_registry(name, t)
+          end.compact.to_h
+          unless global_registry_relationship(type).exclude_fields.include?(:client_integration_id)
+            entity_attributes[:client_integration_id] = global_registry_relationship(type).client_integration_id
+          end
+          entity_attributes[:client_updated_at] = updated_at.to_s(:db) if respond_to?(:updated_at)
+          entity_attributes
+        end
+
+        def relationship_value_for_global_registry(name, type)
+          value = send(name)
+          return [name, value] if value.nil?
+          value = case type
+                  when :datetime, :date
+                    value.to_s(:db)
+                  when :boolean
+                    value ? 'true' : 'false'
+                  else
+                    value.to_s.strip
+                  end
+          [name, value]
+        rescue ::NoMethodError
+          nil
+        end
+
+        def relationship_columns_to_push(type)
+          @relationship_columns_to_push ||= {}
+          @relationship_columns_to_push[type] ||=
+            relationship_entity_columns(type)
+            .reject { |k, _v| global_registry_relationship(type).exclude_fields.include? k }
+            .merge(global_registry_relationship(type).extra_fields)
+        end
+
+        protected
+
+        def normalize_relationship_column_type(type, name)
+          if type.to_s == 'text'
+            :string
+          elsif name.ends_with?('_id')
+            :uuid
+          else
+            type
+          end
+        end
+
+        def relationship_entity_columns(type)
+          return {} if global_registry_relationship(type).primary_class_is_self?
+          self.class
+              .columns
+              .collect do |c|
+            { c.name.underscore.to_sym => normalize_relationship_column_type(c.type, c.name) }
+          end
+              .reduce(&:merge)
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/options.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'global_registry_bindings/options/instance_options'
-require 'global_registry_bindings/options/class_options'
+require 'global_registry_bindings/options/entity_instance_options'
+require 'global_registry_bindings/options/entity_class_options'
+require 'global_registry_bindings/options/relationship_instance_options'
+require 'global_registry_bindings/options/relationship_class_options'
 
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
@@ -9,74 +11,39 @@ module GlobalRegistry #:nodoc:
       extend ActiveSupport::Concern
 
       included do
+        # Entity Class Options
         class_attribute :_global_registry_bindings_class_options
-        self._global_registry_bindings_class_options ||= GlobalRegistry::Bindings::Options::ClassOptions.new(self)
+        self._global_registry_bindings_class_options ||=
+          GlobalRegistry::Bindings::Options::EntityClassOptions.new(self)
+        # Relationship Class Options
+        class_attribute :_global_registry_bindings_class_relationships
+        self._global_registry_bindings_class_relationships = {}
       end
 
-      def global_registry
-        @_global_registry_bindings_instance_options ||= GlobalRegistry::Bindings::Options::InstanceOptions.new(self)
+      def global_registry_entity
+        @_global_registry_bindings_instance_options ||=
+          GlobalRegistry::Bindings::Options::EntityInstanceOptions.new(self)
+      end
+
+      def global_registry_relationship(type)
+        @_global_registry_bindings_instance_relationships ||= {}
+        @_global_registry_bindings_instance_relationships[type] ||=
+          GlobalRegistry::Bindings::Options::RelationshipInstanceOptions.new(type, self)
       end
 
       module ClassMethods
-        def global_registry
+        def global_registry_entity
           _global_registry_bindings_class_options
         end
-      end
-    end
-
-    class OptionsParser
-      def initialize(model_class)
-        @model_class = model_class
-      end
-
-      def defaults
-        {
-          id_column: :global_registry_id,
-          mdm_id_column: nil,
-          type: @model_class.name.demodulize.underscore.to_sym,
-          push_on: %i[create update delete],
-          parent_association: nil,
-          parent_association_class: nil,
-          related_association: nil,
-          related_association_class: nil,
-          parent_relationship_name: nil,
-          related_relationship_name: nil,
-          exclude_fields: %i[id created_at updated_at],
-          extra_fields: {},
-          mdm_timeout: 1.minute
-        }.freeze
-      end
 
-      def parse(options_hash = {})
-        @options = defaults.deep_merge(options_hash) do |key, oldval, newval|
-          if key == :exclude_fields
-            oldval.concat Array.wrap(newval)
-          else
-            newval
-          end
+        def global_registry_relationship(type)
+          _global_registry_bindings_class_relationships[type] ||=
+            GlobalRegistry::Bindings::Options::RelationshipClassOptions.new(type, self)
         end
-        update_excludes
-        validate_options
-        @options
-      end
-
-      private
-
-      def update_excludes
-        @options[:exclude_fields] << @options[:id_column]
-        @options[:exclude_fields] << @options[:mdm_id_column] if @options[:mdm_id_column].present?
-
-        parent_id_column = association_foreign_key @options[:parent_association]
-        @options[:exclude_fields] << parent_id_column.to_sym if parent_id_column
 
-        related_id_column = association_foreign_key @options[:related_association]
-        @options[:exclude_fields] << related_id_column.to_sym if related_id_column
-      end
-
-      def validate_options; end
-
-      def association_foreign_key(name)
-        @model_class.reflect_on_all_associations.detect { |a| a.name == name }&.foreign_key if name
+        def global_registry_relationship_types
+          _global_registry_bindings_options[:relationships].keys
+        end
       end
     end
   end

data/lib/global_registry_bindings/options/entity_class_options.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      class EntityClassOptions
+        delegate :id_column,
+                 :mdm_id_column,
+                 :type,
+                 :mdm_timeout,
+                 :push_on,
+                 :parent_association,
+                 :parent_association_class,
+                 :exclude_fields,
+                 :extra_fields, to: :@options
+
+        def initialize(model_class)
+          @model_class = model_class
+          @options = OpenStruct.new model_class._global_registry_bindings_options[:entity]
+        end
+
+        def ensure_entity_type?
+          @options.ensure_entity_type.present?
+        end
+
+        def mdm_worker_class_name
+          "Pull#{@model_class.name.tr(':', '')}MdmIdWorker"
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/options/entity_instance_options.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      class EntityInstanceOptions
+        delegate :id_column,
+                 :mdm_id_column,
+                 :mdm_timeout,
+                 :push_on,
+                 :parent_association,
+                 :parent_association_class,
+                 :mdm_worker_class_name,
+                 :ensure_entity_type?,
+                 to: :@class_options
+
+        def initialize(model)
+          @model = model
+          @class_options = model.class.global_registry_entity
+        end
+
+        def id_value
+          @model.send id_column
+        end
+
+        def id_value=(value)
+          @model.send "#{id_column}=", value
+        end
+
+        def id_value?
+          @model.send "#{id_column}?"
+        end
+
+        def type
+          t = @class_options.type
+          t.is_a?(Proc) ? t.call(@model) : t
+        end
+
+        def parent
+          @model.send(parent_association) if parent_association.present?
+        end
+
+        def parent_class
+          return if parent_association.blank?
+          parent_association_class
+        end
+
+        def parent_type
+          parent&.global_registry_entity&.type
+        end
+
+        def parent_id_value
+          parent&.global_registry_entity&.id_value
+        end
+
+        def parent_required?
+          parent_association.present? && !parent_is_self?
+        end
+
+        def parent_is_self?
+          parent_association.present? && parent_class == @model.class
+        end
+
+        def exclude_fields
+          option = @class_options.exclude_fields
+          case option
+          when Proc
+            option.call(type, @model)
+          when Symbol
+            @model.send(option, type)
+          else
+            option
+          end
+        end
+
+        def extra_fields
+          option = @class_options.extra_fields
+          case option
+          when Proc
+            option.call(type, @model)
+          when Symbol
+            @model.send(option, type)
+          else
+            option
+          end
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/options/entity_options_parser.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      class EntityOptionsParser
+        def initialize(model_class)
+          @model_class = model_class
+        end
+
+        def defaults
+          {
+            id_column: :global_registry_id,
+            mdm_id_column: nil,
+            type: @model_class.name.demodulize.underscore.to_sym,
+            push_on: %i[create update destroy],
+            parent_association: nil,
+            parent_association_class: nil,
+            parent_relationship_name: nil,
+            exclude_fields: %i[id created_at updated_at],
+            extra_fields: {},
+            mdm_timeout: 1.minute,
+            ensure_entity_type: true
+          }.freeze
+        end
+
+        def parse(options_hash = {})
+          merge_defaults options_hash
+          update_association_classes
+          update_excludes
+          @options
+        end
+
+        private
+
+        def merge_defaults(options_hash = {})
+          @options = defaults.merge(options_hash) do |key, oldval, newval|
+            if key == :exclude_fields
+              case newval
+              when Proc, Symbol
+                newval
+              else
+                oldval.concat Array.wrap(newval)
+              end
+            else
+              newval
+            end
+          end
+        end
+
+        def update_association_classes
+          unless @options[:parent_association_class] # rubocop:disable Style/GuardClause
+            @options[:parent_association_class] = association_class @options[:parent_association]
+          end
+        end
+
+        def update_excludes
+          return unless @options[:exclude_fields].is_a? Array
+          @options[:exclude_fields] << @options[:id_column]
+          @options[:exclude_fields] << @options[:mdm_id_column] if @options[:mdm_id_column].present?
+
+          parent_id_column = association_foreign_key @options[:parent_association]
+          @options[:exclude_fields] << parent_id_column.to_sym if parent_id_column
+        end
+
+        def association_foreign_key(name)
+          @model_class.reflect_on_association(name)&.foreign_key&.to_sym
+        end
+
+        def association_class(name)
+          @model_class.reflect_on_association(name)&.klass
+        end
+      end
+    end
+  end
+end