global-registry-bindings 0.0.6 → 0.1.0

data/lib/global_registry_bindings/entity/relationship_type_methods.rb

@@ -8,50 +8,61 @@ module GlobalRegistry #:nodoc:
       module RelationshipTypeMethods
         extend ActiveSupport::Concern
 
-        module ClassMethods
-          def push_global_registry_relationship_type # rubocop:disable Metrics/MethodLength
-            parent_entity_type_id, related_entity_type_id = associated_entity_ids
-
-            relationship_type = Rails.cache.fetch(relationship_type_cache_key, expires_in: 1.hour) do
-              GlobalRegistry::RelationshipType.get(
-                'filters[between]' => "#{parent_entity_type_id},#{related_entity_type_id}"
-              )['relationship_types'].detect do |r|
-                r['relationship1']['relationship_name'] == global_registry.parent_relationship_name.to_s
-              end
-            end
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
+        def push_global_registry_relationship_type
+          return unless global_registry_relationship(type).ensure_relationship_type?
+          primary_entity_type_id, related_entity_type_id = associated_entity_ids
 
-            unless relationship_type
-              relationship_type =
-                GlobalRegistry::RelationshipType.post(relationship_type: {
-                                                        entity_type1_id: parent_entity_type_id,
-                                                        entity_type2_id: related_entity_type_id,
-                                                        relationship1: global_registry.parent_relationship_name,
-                                                        relationship2: global_registry.related_relationship_name
-                                                      })['relationship_type']
+          relationship_type = Rails.cache.fetch(relationship_type_cache_key, expires_in: 1.hour) do
+            GlobalRegistry::RelationshipType.get(
+              'filters[between]' => "#{primary_entity_type_id},#{related_entity_type_id}"
+            )['relationship_types'].detect do |r|
+              r['relationship1']['relationship_name'] ==
+                global_registry_relationship(type).primary_relationship_name.to_s
             end
-            push_global_registry_relationship_type_fields(relationship_type)
-            relationship_type
           end
 
-          def associated_entity_ids
-            [global_registry.parent_class.send(:push_entity_type)&.dig('id'),
-             global_registry.related_class.send(:push_entity_type)&.dig('id')]
+          unless relationship_type
+            relationship_type =
+              GlobalRegistry::RelationshipType.post(
+                relationship_type: {
+                  entity_type1_id: primary_entity_type_id,
+                  entity_type2_id: related_entity_type_id,
+                  relationship1: global_registry_relationship(type).primary_relationship_name,
+                  relationship2: global_registry_relationship(type).related_relationship_name
+                }
+              )['relationship_type']
           end
+          push_global_registry_relationship_type_fields(relationship_type)
+          relationship_type
+        end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/AbcSize
 
-          def push_global_registry_relationship_type_fields(relationship_type)
-            existing_fields = relationship_type['fields']&.collect { |f| f['name'].to_sym } || []
-            fields = columns_to_push
-                     .reject { |k, _v| existing_fields.include? k }
-                     .map { |name, type| { name: name, field_type: type } }
-            return if fields.empty?
-            GlobalRegistry::RelationshipType.put(relationship_type['id'],
-                                                 relationship_type: { fields: fields })
-          end
+        def associated_entity_ids
+          primary_worker =
+            GlobalRegistry::Bindings::Workers::PushEntityWorker.new global_registry_relationship(type).primary
+          related_worker =
+            GlobalRegistry::Bindings::Workers::PushEntityWorker.new global_registry_relationship(type).related
+          [primary_worker.send(:push_entity_type_to_global_registry)&.dig('id'),
+           related_worker.send(:push_entity_type_to_global_registry)&.dig('id')]
+        end
 
-          def relationship_type_cache_key
-            "GlobalRegistry::Bindings::RelationshipType::#{global_registry.parent_type}::" \
-              "#{global_registry.related_type}::#{global_registry.parent_relationship_name}"
-          end
+        def push_global_registry_relationship_type_fields(relationship_type)
+          existing_fields = relationship_type['fields']&.collect { |f| f['name'].to_sym } || []
+          fields = model.relationship_columns_to_push(type)
+                        .reject { |k, _v| existing_fields.include? k }
+                        .map { |name, type| { name: name, field_type: type } }
+          return if fields.empty?
+          GlobalRegistry::RelationshipType.put(relationship_type['id'],
+                                               relationship_type: { fields: fields })
+        end
+
+        def relationship_type_cache_key
+          "GlobalRegistry::Bindings::RelationshipType::#{global_registry_relationship(type).primary_type}::" \
+            "#{global_registry_relationship(type).related_type}::" \
+            "#{global_registry_relationship(type).primary_relationship_name}"
         end
       end
     end

data/lib/global_registry_bindings/exceptions.rb

@@ -6,5 +6,6 @@ module GlobalRegistry #:nodoc:
     class EntityMissingMdmId < StandardError; end
     class RelatedEntityMissingGlobalRegistryId < StandardError; end
     class ParentEntityMissingGlobalRegistryId < StandardError; end
+    class RelatedEntityExistsWithCID < StandardError; end
   end
 end

data/lib/global_registry_bindings/global_registry_bindings.rb

@@ -4,13 +4,15 @@ require 'active_support/core_ext'
 require 'global_registry'
 require 'global_registry_bindings/exceptions'
 require 'global_registry_bindings/options'
-require 'global_registry_bindings/entity/entity_methods'
-require 'global_registry_bindings/entity/entity_type_methods'
-require 'global_registry_bindings/entity/relationship_type_methods'
-require 'global_registry_bindings/entity/push_entity_methods'
-require 'global_registry_bindings/entity/delete_entity_methods'
-require 'global_registry_bindings/entity/mdm_methods'
-require 'global_registry_bindings/entity/push_relationship_methods'
+require 'global_registry_bindings/options/entity_options_parser'
+require 'global_registry_bindings/options/relationship_options_parser'
+require 'global_registry_bindings/model/entity'
+require 'global_registry_bindings/model/push_entity'
+require 'global_registry_bindings/model/push_relationship'
+require 'global_registry_bindings/model/delete_entity'
+require 'global_registry_bindings/model/pull_mdm'
+require 'global_registry_bindings/model/relationship'
+require 'global_registry_bindings/worker'
 
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
@@ -18,59 +20,140 @@ module GlobalRegistry #:nodoc:
     #
     # Options:
     #
-    # * `:id_column`: Column used to track the Global Registry ID for the model instance. Can be a :string or :uuid
-    #   column. (default: `:global_registry_id`)
-    # * `:mdm_id_column`: Column used to enable MDM tracking and set the name of the column. MDM is disabled when this
-    #    option is nil or empty. (default: `nil`)
-    # * `:type`: Global Registry entity type. Default value is underscored name of the model.
+    # * `:binding`: Type of Global Registry binding. Either `:entity` or `:relationship`.
+    #   (default: `:entity`)
+    #
+    # * `:id_column`: Column used to track the Global Registry ID for the model instance or relationship entity.
+    #    Can be a :string or :uuid column. (default: `:global_registry_id`) **[`:entity`, `:relationship`]**
+    #
+    # * `:type`: Global Registry entity type. Accepts a Symbol or a Proc. Symbol is the name of the entity type, Proc
+    #   is passed the model instance and must return a symbol which is the entity type. Default value is underscored
+    #   name of the model. Ex: ```type: proc { |model| model.name.to_sym }```. When used in a `:relationship`, `:type`
+    #   is a unique name to identify the relationship. **[`:entity`, `:relationship`]**
+    #
     # * `:push_on`: Array of Active Record lifecycle events used to push changes to Global Registry.
-    #    (default: `[:create, :update, :delete]`)
+    #   (default: `[:create, :update, :destroy]`) **[`:entity`]**
+    #
     # * `:parent_association`: Name of the Active Record parent association. Must be defined before calling
-    #    global_registry_bindings in order to determine foreign_key field. (default: `nil`)
+    #   global_registry_bindings in order to determine foreign_key for use in exclude_fields. Used to create a
+    #   hierarchy or to push child entity types. (Ex: person -> address) (default: `nil`) **[`:entity`]**
+    #
     # * `:parent_association_class`: Class name of the parent model. Required if `:parent_association` can not be used
-    #    to determine the parent class. This can happen if parent is defined by another gem, like `has_ancestry`.
-    #    (default: `nil`)
-    # * `:related_association`: Name of the Active Record related association. Setting this option changes the
-    #    global registry binding from entity to relationship. Active Record association must be defined before calling
-    #    global_registry_bindings in order to determine the foreign key. `:parent_relationship_name` and
-    #    `:related_relationship_name` must be set for relationship binding to work. (default: `nil`)
+    #   to determine the parent class. This can happen if parent is defined by another gem, like `ancestry`.
+    #   (default: `nil`) **[`:entity`]**
+    #
+    # * `:primary_association`: Name of the Active Record primary association. Must be defined before calling
+    #   global_registry_bindings in order to determine foreign_key for use in exclude_fields. (default: `nil`)
+    #   **[`:relationship`]**
+    #
+    # * `:primary_association_class`: Class name of the primary model. Required if `:primary_association` can not be
+    #   used to determine the parent class. This can happen if parent is defined by another gem, like `ancestry`.
+    #   (default: `self.class`) **[`:relationship`]**
+    #
+    # * `:primary_association_foreign_key`: Foreign Key column for the primary association. Used if foreign_key can
+    #   not be determined from `:primary_association`. (default: `:primary_association.foreign_key`)
+    #   **[`:relationship`]**
+    #
+    # * `:related_association`: Name of the Active Record related association. Active Record association must be
+    #   defined before calling global_registry_bindings in order to determine the foreign key.
+    #   (default: `nil`) **[`:relationship`]**
+    #
     # * `:related_association_class`: Class name of the related model. Required if `:related_association` can not be
-    #    used to determine the related class. (default: `nil`)
-    # * `:parent_relationship_name`: Name of parent relationship role. (default: `nil`)
-    # * `:related_relationship_name`: Name of the related relationship role. (default: `nil`)
-    # * `:exclude_fields`: Model fields to exclude when pushing to Global Registry. Will additionally include
-    #   `:mdm_id_column` and `:parent_association` foreign key when defined.
-    #   (default:  `[:id, :created_at, :updated_at, :global_registry_id]`)
-    # * `:extra_fields`: Additional fields to send to Global Registry. This should be a hash with name as the key
-    #    and :type attributes as the value. Ex: `{language: :string}`. Name is a symbol and type is an ActiveRecord
-    #    column type.
+    #    used to determine the related class. (default: `nil`) **[`:relationship`]**
+    #
+    # * `:related_association_foreign_key`: Foreign Key column for the related association. Used if foreign_key can
+    #   not be determined from `:primary_association`. (default: `:primary_association.foreign_key`)
+    #   **[`:relationship`]**
+    #
+    # * `:primary_relationship_name`: Name of primary relationship role. Required if `:ensure_relationship_type` is
+    #   `true`. (default: `nil`) **[`:relationship`]**
+    #
+    # * `:related_relationship_name`: Name of the related relationship role. Required if `:ensure_relationship_type`
+    #   is `true`. (default: `nil`) **[`:relationship`]**
+    #
+    # * `:related_association_type`: Name of the related association entity_type. Required if unable to determined
+    #   `:type` from related. (default: `nil`) **[`:relationship`]**
+    #
+    # * `:related_global_registry_id`: Global Registry ID of a remote related entity. Proc or Symbol. Implementation
+    #   should cache this as it may be requested multiple times. (default: `nil`) **[`:relationship`]**
+    #
+    # * `:ensure_relationship_type`: Ensure Global Registry RelationshipType exists and is up to date.
+    #   (default: `true`) **[`:relationship`]**
+    #
+    # * `:ensure_entity_type`: Ensure Global Registry Entity Type exists and is up to date.
+    #   (default: `true`) **[`:entity`]**
+    #
+    # * `:client_integration_id`: Client Integration ID for relationship. Proc or Symbol.
+    #    (default: `:primary_association.id`) **[`:relationship`]**
+    #
+    # * `:exclude_fields`: Array, Proc or Symbol. Array of Model fields (as symbols) to exclude when pushing to Global
+    #    Registry. Array Will additionally include `:mdm_id_column` and `:parent_association` foreign key when defined.
+    #    If Proc, is passed type and model instance and should return an Array of the fields to exclude. If Symbol,
+    #    this should be a method name the Model instance responds to. It is passed the type and should return an Array
+    #    of fields to exclude. When Proc or Symbol are used, you must explicitly return the standard defaults.
+    #    (default:  `[:id, :created_at, :updated_at, :global_registry_id]`) **[`:entity`, `:relationship`]**
+    #
+    # * `:extra_fields`: Additional fields to send to Global Registry. Hash, Proc or Symbol. As a Hash, names are the
+    #    keys and :type attributes are the values. Ex: `{language: :string}`. Name is a symbol and type is an
+    #    ActiveRecord column type. As a Proc, it is passed the type and model instance, and should return a Hash.
+    #    As a Symbol, the model should respond to this method, is passed the type, and should return a Hash.
+    #    **[`:entity`, `:relationship`]**
+    #
+    # * `:mdm_id_column`: Column used to enable MDM tracking and set the name of the column. MDM is disabled when this
+    #   option is nil or empty. (default: `nil`) **[`:entity`]**
+    #
     # * `:mdm_timeout`: Only pull mdm information at most once every `:mdm_timeout`. (default: `1.minute`)
+    #   **[`:entity`]**
     #
     # @api public
     def global_registry_bindings(options = {})
-      global_registry_bindings_parse_options! options
+      options[:binding] ||= :entity
+      unless method_defined? :_global_registry_bindings_options
+        class_attribute :_global_registry_bindings_options
+        self._global_registry_bindings_options = { entity: nil, relationships: {} }
+      end
+      if options[:binding] == :entity
+        global_registry_bindings_entity options
+      elsif options[:binding] == :relationship
+        global_registry_bindings_relationship options
+      else
+        raise ArgumentError, ':binding option must be :entity or :relationship'
+      end
+    end
 
-      include Options
-      include Entity::EntityMethods
-      if global_registry.push_on.any? { |item| %i[create update].include? item }
-        if global_registry.related_association && global_registry.parent_association
-          include Entity::RelationshipTypeMethods
-          include Entity::PushRelationshipMethods
-        else
-          include Entity::EntityTypeMethods
-          include Entity::PushEntityMethods
-        end
+    private
+
+    def global_registry_bindings_entity(options = {})
+      if _global_registry_bindings_options[:entity].present?
+        raise '#global_registry_bindings with :entity binding called more than once.'
       end
+      _global_registry_bindings_options[:entity] = GlobalRegistry::Bindings::Options::EntityOptionsParser.new(self)
+                                                                                                         .parse(options)
+      include Options unless respond_to? :global_registry_entity
+      global_registry_bindings_entity_includes
+    end
+
+    def global_registry_bindings_relationship(options = {})
+      options = GlobalRegistry::Bindings::Options::RelationshipOptionsParser.new(self).parse(options)
+      _global_registry_bindings_options[:relationships][options[:type]] = options
 
-      include Entity::DeleteEntityMethods if global_registry.push_on.include? :delete
-      include Entity::MdmMethods if global_registry.mdm_id_column.present?
+      include Options unless respond_to? :global_registry_entity
+      global_registry_bindings_relationship_includes(options[:type])
     end
 
-    private
+    def global_registry_bindings_entity_includes
+      include Model::Entity
+      if global_registry_entity.push_on.any? { |item| %i[create update].include? item }
+        include Model::PushEntity
+      end
+
+      include Model::DeleteEntity if global_registry_entity.push_on.include? :destroy
+      include Model::PullMdm if global_registry_entity.mdm_id_column.present?
+    end
 
-    def global_registry_bindings_parse_options!(options)
-      class_attribute :_global_registry_bindings_options_hash
-      self._global_registry_bindings_options_hash = GlobalRegistry::Bindings::OptionsParser.new(self).parse(options)
+    def global_registry_bindings_relationship_includes(_type)
+      include Model::Relationship
+      include Model::PushRelationship
     end
   end
 end

data/lib/global_registry_bindings/{entity/delete_entity_methods.rb → model/delete_entity.rb}

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'global_registry_bindings/workers/delete_gr_entity_worker'
+require 'global_registry_bindings/workers/delete_entity_worker'
 
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
-    module Entity #:nodoc:
-      module DeleteEntityMethods
+    module Model #:nodoc:
+      module DeleteEntity
         extend ActiveSupport::Concern
 
         included do
@@ -13,8 +13,8 @@ module GlobalRegistry #:nodoc:
         end
 
         def delete_entity_from_global_registry_async
-          return unless global_registry.id_value?
-          ::GlobalRegistry::Bindings::Workers::DeleteGrEntityWorker.perform_async(global_registry.id_value)
+          return unless global_registry_entity.id_value?
+          ::GlobalRegistry::Bindings::Workers::DeleteEntityWorker.perform_async(global_registry_entity.id_value)
         end
       end
     end

data/lib/global_registry_bindings/model/entity.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Model #:nodoc:
+      module Entity
+        extend ActiveSupport::Concern
+
+        def entity_attributes_to_push
+          entity_attributes = entity_columns_to_push.map do |name, type|
+            value_for_global_registry(name, type)
+          end.compact.to_h
+          entity_attributes[:client_integration_id] = id unless global_registry_entity.exclude_fields
+                                                                                      .include?(:client_integration_id)
+          entity_attributes[:client_updated_at] = updated_at.to_s(:db) if respond_to?(:updated_at)
+          if global_registry_entity.parent_is_self?
+            entity_attributes[:parent_id] = global_registry_entity.parent_id_value
+          end
+          entity_attributes
+        end
+
+        def 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 entity_columns_to_push
+          @columns_to_push ||= self
+                               .class
+                               .columns
+                               .collect do |c|
+                                 { c.name.underscore.to_sym => normalize_entity_column_type(c.type, c.name) }
+                               end # rubocop:disable Style/MultilineBlockChain
+                               .reduce(&:merge)
+                               .reject { |k, _v| global_registry_entity.exclude_fields.include? k }
+                               .merge(global_registry_entity.extra_fields)
+        end
+
+        protected
+
+        def normalize_entity_column_type(type, name)
+          if type.to_s == 'text'
+            :string
+          elsif name.ends_with?('_id')
+            :uuid
+          else
+            type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/model/pull_mdm.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'global_registry_bindings/workers/pull_mdm_id_worker'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Model #:nodoc:
+      module PullMdm
+        extend ActiveSupport::Concern
+
+        included do
+          GlobalRegistry::Bindings::Workers.mdm_worker_class(self)
+          after_commit :pull_mdm_id_from_global_registry_async, on: %i[create update]
+        end
+
+        def pull_mdm_id_from_global_registry_async
+          "::GlobalRegistry::Bindings::Workers::#{global_registry_entity.mdm_worker_class_name}"
+            .constantize .perform_async(self.class, id)
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/model/push_entity.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'global_registry_bindings/workers/push_entity_worker'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Model #:nodoc:
+      module PushEntity
+        extend ActiveSupport::Concern
+
+        included do
+          after_commit :push_entity_to_global_registry_async, on: (global_registry_entity.push_on - %i[destroy])
+        end
+
+        def push_entity_to_global_registry_async
+          ::GlobalRegistry::Bindings::Workers::PushEntityWorker.perform_async(self.class, id)
+        end
+      end
+    end
+  end
+end