global-registry-bindings 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc5f397574e48c4f792014e06ab828b3ff015663
-  data.tar.gz: 6907779fa74f374191b706e28ffd9253dfd0ea23
+  metadata.gz: 451f38a412ca7fd1e2b05ff8e96d56deb1b672a8
+  data.tar.gz: 9af6074f11baf7031348356041f970dae848241f
 SHA512:
-  metadata.gz: bedf745fc6e7c872315b457ca1edd8f74a98bdea2df0e1e086d9137b11346c59b753fa49ccde821fed2cfc1aab2c795f9cecda6f6e2ea964e504e08d322659c7
-  data.tar.gz: c8422e9859e07b0105f4b16294bd28207097b810423962c2318024ba3aadcc590ef3500948bc4cbe04c8a4951a86dbcb65f433def74f837739785f3b9966af44
+  metadata.gz: 4d496aebf53060214bf787551c9b45b306ebf0a333f9840dc33383d17faa8d19345b9d5563a46f3a5af2f4831cd1ac505ab9e2ec22f9e68cc6e82b077bd09ad5
+  data.tar.gz: 06f34a68d132652485564106595954833b359e8c0054b679f09227aff5923ae08ffe5f3212d08863da828605bf4b9871150d76ccf625a92fef6049d5ff370580

data/README.md

@@ -49,32 +49,90 @@ end
 
 You can pass various options to the `global_registry_bindings` method. Configuration options are:
 
-* `: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`]**
 
 ## Values for `extra_fields`
 
@@ -106,20 +164,6 @@ class Person < ActiveRecord::Base
 end
 ```
 
-## Relationships
-
-Global Registry allows for relating two entities together (many-to-many) through a relationship. An example of this
-could be a Person to Person relationship. This relationship could be described as husband/spouse, or even
-leader/employee. You could also relate a Person to an Organization through an assignment. The assignment can track
-specific fields about the relationship.
-
-`global-registry-bindings` supports this through the `:parent_association` and `:related_association` options.
-Relationship roles, like husband/wife, are defined through the `:parent_relationship_name` and
-`:related_relationship_name` options.
-
-More information on Global Registry relationships and relationship types can be found
-[here](https://github.com/CruGlobal/global_registry_docs/wiki/About-Relationships)
-
 ## Example Models
 
 Example models can be found in the [specs](https://github.com/CruGlobal/global-registry-bindings/tree/master/spec/internal/app/models).

data/lib/global_registry_bindings/entity/entity_type_methods.rb

@@ -8,46 +8,48 @@ module GlobalRegistry #:nodoc:
       module EntityTypeMethods
         extend ActiveSupport::Concern
 
-        module ClassMethods
-          def push_entity_type
-            parent_entity_id = parent_entity_type_id
-            entity_type = Rails.cache.fetch(entity_type_cache_key, expires_in: 1.hour) do
-              GlobalRegistry::EntityType.get('filters[name]' => global_registry.type,
-                                             'filters[parent_id]' => parent_entity_id)['entity_types']&.first
-            end
-
-            unless entity_type
-              entity_type = GlobalRegistry::EntityType.post(entity_type: { name: global_registry.type,
-                                                                           parent_id: parent_entity_id,
-                                                                           field_type: 'entity' })['entity_type']
-            end
-
-            push_entity_type_fields(entity_type)
-            entity_type
+        def push_entity_type_to_global_registry
+          return unless global_registry_entity.ensure_entity_type?
+          parent_entity_id = parent_entity_type_id
+          entity_type = Rails.cache.fetch(entity_type_cache_key, expires_in: 1.hour) do
+            GlobalRegistry::EntityType.get('filters[name]' => global_registry_entity.type,
+                                           'filters[parent_id]' => parent_entity_id)['entity_types']&.first
           end
 
-          def push_entity_type_fields(entity_type)
-            existing_fields = entity_type['fields']&.collect { |f| f['name'].to_sym } || []
-            columns_to_push
-              .reject { |k, _v| existing_fields.include? k }
-              .each do |name, type|
-              GlobalRegistry::EntityType.post(entity_type: { name: name,
-                                                             parent_id: entity_type['id'],
-                                                             field_type: type })
-            end
+          unless entity_type
+            entity_type = GlobalRegistry::EntityType.post(entity_type: { name: global_registry_entity.type,
+                                                                         parent_id: parent_entity_id,
+                                                                         field_type: 'entity' })['entity_type']
           end
 
-          def parent_entity_type_id
-            parent_type = global_registry&.parent_type
-            return if parent_type.blank? || global_registry.parent_is_self?
-            parent_entity_type = global_registry.parent_class.send :push_entity_type
-            parent_entity_type&.dig('id')
-          end
+          push_entity_type_fields_to_global_registry(entity_type)
+          entity_type
+        end
 
-          def entity_type_cache_key
-            "GlobalRegistry::Bindings::EntityType::#{global_registry.type}"
+        private
+
+        def push_entity_type_fields_to_global_registry(entity_type)
+          existing_fields = entity_type['fields']&.collect { |f| f['name'].to_sym } || []
+          model.entity_columns_to_push
+               .reject { |k, _v| existing_fields.include? k }
+               .each do |name, type|
+            GlobalRegistry::EntityType.post(entity_type: { name: name,
+                                                           parent_id: entity_type['id'],
+                                                           field_type: type })
           end
         end
+
+        def parent_entity_type_id
+          parent = global_registry_entity&.parent
+          return if parent.blank? || global_registry_entity.parent_is_self?
+          worker = GlobalRegistry::Bindings::Workers::PushEntityWorker.new parent
+          parent_entity_type = worker.send :push_entity_type_to_global_registry
+          parent_entity_type&.dig('id')
+        end
+
+        def entity_type_cache_key
+          "GlobalRegistry::Bindings::EntityType::#{global_registry_entity.type}"
+        end
       end
     end
   end

data/lib/global_registry_bindings/entity/mdm_methods.rb

@@ -1,37 +1,27 @@
 # frozen_string_literal: true
 
-require 'global_registry_bindings/workers/pull_mdm_id_worker'
-
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
     module Entity #:nodoc:
       module MdmMethods
         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.mdm_worker_class_name}".constantize
-                                                                                         .perform_async(self.class, id)
-        end
-
         def pull_mdm_id_from_global_registry # rubocop:disable Metrics/AbcSize
-          unless global_registry.id_value?
+          unless global_registry_entity.id_value?
             # Record missing Global Registry ID, enqueue it to be pushed.
-            push_entity_to_global_registry_async
+            model.push_entity_to_global_registry_async
             raise GlobalRegistry::Bindings::RecordMissingGlobalRegistryId,
-                  "#{self.class.name} #{id} has no #{global_registry.id_column}; will retry"
+                  "#{model.class.name}(#{model.id}) has no #{global_registry_entity.id_column}; will retry"
           end
-          entity = GlobalRegistry::Entity.find(global_registry.id_value, 'filters[owned_by]' => 'mdm')
-          mdm_entity_id = dig_global_registry_mdm_id_from_entity(entity, global_registry.type.to_s)
+          entity = GlobalRegistry::Entity.find(global_registry_entity.id_value, 'filters[owned_by]' => 'mdm')
+          mdm_entity_id = dig_global_registry_mdm_id_from_entity(entity, global_registry_entity.type.to_s)
           unless mdm_entity_id
             raise GlobalRegistry::Bindings::EntityMissingMdmId,
-                  "GR entity #{global_registry.id_value} for #{self.class.name} #{id} has no mdm id; will retry"
+                  "GR entity #{global_registry_entity.id_value} for #{model.class.name}(#{model.id}) has no mdm id; " \
+                  'will retry'
           end
-          update_column(global_registry.mdm_id_column, mdm_entity_id) # rubocop:disable Rails/SkipsModelValidations
+          # rubocop:disable Rails/SkipsModelValidations
+          model.update_column(global_registry_entity.mdm_id_column, mdm_entity_id)
         end
 
         def dig_global_registry_mdm_id_from_entity(entity, type)

data/lib/global_registry_bindings/entity/push_entity_methods.rb

@@ -1,82 +1,75 @@
 # frozen_string_literal: true
 
-require 'global_registry_bindings/workers/push_gr_entity_worker'
-
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
     module Entity #:nodoc:
       module PushEntityMethods
         extend ActiveSupport::Concern
 
-        included do
-          after_commit :push_entity_to_global_registry_async, on: (global_registry.push_on - %i[delete])
-        end
-
-        def push_entity_to_global_registry_async
-          ::GlobalRegistry::Bindings::Workers::PushGrEntityWorker.perform_async(self.class, id)
-        end
-
-        def push_entity_to_global_registry
-          self.class.push_entity_type
+        def push_entity_to_global_registry # rubocop:disable Metrics/PerceivedComplexity
+          return if global_registry_entity.parent_required? && global_registry_entity.parent.blank?
+          push_entity_type_to_global_registry
 
-          if global_registry.parent_type.present? && !global_registry.parent_is_self?
+          if global_registry_entity.parent_type.present? && !global_registry_entity.parent_is_self?
             create_dependent_entity_in_global_registry
-          elsif global_registry.id_value?
+          elsif global_registry_entity.id_value?
             update_entity_in_global_registry
           else
             create_entity_in_global_registry
           end
         rescue RestClient::ResourceNotFound
-          global_registry.id_value = nil
+          global_registry_entity.id_value = nil
           push_entity_to_global_registry
         end
 
         def update_entity_in_global_registry
-          entity_attributes = { global_registry.type => entity_attributes_to_push }
-          GlobalRegistry::Entity.put(global_registry.id_value, entity: entity_attributes)
+          entity_attributes = { global_registry_entity.type => model.entity_attributes_to_push }
+          GlobalRegistry::Entity.put(global_registry_entity.id_value, entity: entity_attributes)
         end
 
         def create_entity_in_global_registry
-          ensure_parent_entity_has_global_registry_id! if global_registry.parent.present?
-          entity_attributes = { global_registry.type => entity_attributes_to_push }
+          ensure_parent_entity_has_global_registry_id! if global_registry_entity.parent.present?
+          entity_attributes = { global_registry_entity.type => model.entity_attributes_to_push }
           entity = GlobalRegistry::Entity.post(entity: entity_attributes)
-          global_registry.id_value = dig_global_registry_id_from_entity(entity['entity'], global_registry.type)
-          update_column(global_registry.id_column, # rubocop:disable Rails/SkipsModelValidations
-                        global_registry.id_value)
+          global_registry_entity.id_value = dig_global_registry_id_from_entity(entity['entity'],
+                                                                               global_registry_entity.type)
+          model.update_column(global_registry_entity.id_column, # rubocop:disable Rails/SkipsModelValidations
+                              global_registry_entity.id_value)
         end
 
         # Create or Update a child entity (ex: :email_address is a child of :person)
         def create_dependent_entity_in_global_registry # rubocop:disable Metrics/AbcSize
-          return if global_registry.parent.blank?
-          global_registry.parent.push_entity_to_global_registry if global_registry.parent_id_value.blank?
+          return if global_registry_entity.parent.blank?
+          ensure_parent_entity_has_global_registry_id!
           entity_attributes = {
-            global_registry.parent_type => {
-              client_integration_id: global_registry.parent.id,
-              global_registry.type => entity_attributes_to_push
+            global_registry_entity.parent_type => {
+              client_integration_id: global_registry_entity.parent.id,
+              global_registry_entity.type => model.entity_attributes_to_push
             }
           }
-          entity = GlobalRegistry::Entity.put(global_registry.parent_id_value, entity: entity_attributes)
-          global_registry.id_value = dig_global_registry_id_from_entity(entity['entity'],
-                                                                        global_registry.type,
-                                                                        global_registry.parent_type)
-          update_column(global_registry.id_column, # rubocop:disable Rails/SkipsModelValidations
-                        global_registry.id_value)
+          entity = GlobalRegistry::Entity.put(global_registry_entity.parent_id_value, entity: entity_attributes)
+          global_registry_entity.id_value = dig_global_registry_id_from_entity(entity['entity'],
+                                                                               global_registry_entity.type,
+                                                                               global_registry_entity.parent_type)
+          model.update_column(global_registry_entity.id_column, # rubocop:disable Rails/SkipsModelValidations
+                              global_registry_entity.id_value)
         end
 
         def dig_global_registry_id_from_entity(entity, type, parent_type = nil)
           return entity&.dig(type.to_s, 'id') unless parent_type
           Array.wrap(entity&.dig(parent_type.to_s, type.to_s)).detect do |item|
-            item['client_integration_id'] == id.to_s
+            item['client_integration_id'] == model.id.to_s
           end&.dig('id')
         end
 
         def ensure_parent_entity_has_global_registry_id!
-          return unless global_registry.parent_is_self? && global_registry.parent_id_value.blank?
+          return unless (global_registry_entity.parent_is_self? && global_registry_entity.parent_id_value.blank?) ||
+                        global_registry_entity.parent_id_value.blank?
           # Push parent entity if it exists and is missing global_registry_id
-          global_registry.parent.push_entity_to_global_registry_async
+          global_registry_entity.parent.push_entity_to_global_registry_async
           raise GlobalRegistry::Bindings::ParentEntityMissingGlobalRegistryId,
-                "#{self.class.name}(#{id}) has parent entity " \
-                "#{global_registry.parent.class.name}(#{global_registry.parent.id}) missing " \
+                "#{model.class.name}(#{model.id}) has parent entity " \
+                "#{global_registry_entity.parent.class.name}(#{global_registry_entity.parent.id}) missing " \
                 'global_registry_id; will retry.'
         end
       end

data/lib/global_registry_bindings/entity/push_relationship_methods.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'global_registry'
-require 'global_registry_bindings/workers/push_relationship_worker'
+require 'global_registry_bindings/workers/delete_entity_worker'
 
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
@@ -9,71 +9,85 @@ module GlobalRegistry #:nodoc:
       module PushRelationshipMethods
         extend ActiveSupport::Concern
 
-        included do
-          after_commit :push_relationship_to_global_registry_async, on: (global_registry.push_on - %i[delete])
-        end
-
-        def push_relationship_to_global_registry_async
-          ::GlobalRegistry::Bindings::Workers::PushRelationshipWorker.perform_async(self.class, id)
-        end
-
         def push_relationship_to_global_registry
           ensure_related_entities_have_global_registry_ids!
-          self.class.push_global_registry_relationship_type
-
-          if global_registry.id_value?
-            update_relationship_in_global_registry
-          else
-            create_relationship_in_global_registry
-          end
-        end
-
-        def update_relationship_in_global_registry
-          GlobalRegistry::Entity.put(global_registry.id_value, entity: entity_attributes_to_push)
+          push_global_registry_relationship_type
+          create_relationship_in_global_registry
         end
 
-        def create_relationship_in_global_registry # rubocop:disable Metrics/AbcSize
-          entity = GlobalRegistry::Entity.put(global_registry.parent_id_value,
-                                              { entity:  { global_registry.parent_type => {
-                                                "#{global_registry.related_relationship_name}:relationship" =>
-                                                  entity_attributes_to_push.merge(global_registry.related_type =>
-                                                                                    global_registry.related_id_value)
-                                              }, client_integration_id: global_registry.parent.id } },
-                                              params: {
-                                                full_response: true,
-                                                fields: "#{global_registry.related_relationship_name}:relationship"
-                                              })
-          global_registry.id_value = global_registry_relationship_entity_id_from_entity entity
-          update_column(global_registry.id_column, # rubocop:disable Rails/SkipsModelValidations
-                        global_registry.id_value)
-          # Update relationship to work around bug in Global Registry
-          # - If current system doesn't own a copy of the parent entity, then creating a new relationship in the same
-          #   request will not add the relationship entity_type properties.
-          update_relationship_in_global_registry if global_registry.id_value?
+        def create_relationship_in_global_registry
+          entity = put_relationship_to_global_registry
+          global_registry_relationship(type).id_value = global_registry_relationship_entity_id_from_entity entity
+          model.update_column( # rubocop:disable Rails/SkipsModelValidations
+            global_registry_relationship(type).id_column,
+            global_registry_relationship(type).id_value
+          )
         end
 
         def global_registry_relationship_entity_id_from_entity(entity)
-          relationships = Array.wrap entity.dig('entity', global_registry.parent_type.to_s,
-                                                "#{global_registry.related_relationship_name}:relationship")
+          relationships = Array.wrap entity.dig(
+            'entity',
+            global_registry_relationship(type).primary_type.to_s,
+            "#{global_registry_relationship(type).related_relationship_name}:relationship"
+          )
           relationships.detect do |rel|
             cid = rel['client_integration_id']
             cid = cid['value'] if cid.is_a?(Hash)
-            cid == id.to_s
+            cid == global_registry_relationship(type).client_integration_id.to_s
           end&.dig('relationship_entity_id')
         end
 
-        def ensure_related_entities_have_global_registry_ids!
-          return if global_registry.parent_id_value.present? && global_registry.related_id_value.present?
+        def ensure_related_entities_have_global_registry_ids! # rubocop:disable Metrics/AbcSize
+          if global_registry_relationship(type).primary_id_value.present? &&
+             global_registry_relationship(type).related_id_value.present?
+            return
+          end
           # Enqueue push_entity worker for related entities missing global_registry_id and retry relationship push
           names = []
-          [global_registry.parent, global_registry.related].each do |model|
-            next if model.global_registry.id_value?
+          [global_registry_relationship(type).primary, global_registry_relationship(type).related].each do |model|
+            next if model.global_registry_entity.id_value?
             names << "#{model.class.name}(#{model.id})"
             model.push_entity_to_global_registry_async
           end
           raise GlobalRegistry::Bindings::RelatedEntityMissingGlobalRegistryId,
-                "#{self.class.name}(#{id}) has related entities [#{names.join ', '}] missing global_registry_id;" \
-                  ' will retry.'
+                "#{model.class.name}(#{model.id}) has related entities [#{names.join ', '}] missing " \
+                'global_registry_id; will retry.'
+        end
+
+        def relationship_entity
+          { entity:  { global_registry_relationship(type).primary_type => {
+            "#{global_registry_relationship(type).related_relationship_name}:relationship" =>
+              model.relationship_attributes_to_push(type)
+                   .merge(global_registry_relationship(type).related_type =>
+                         global_registry_relationship(type).related_id_value)
+          }, client_integration_id: global_registry_relationship(type).primary.id } }
+        end
+
+        def put_relationship_to_global_registry
+          GlobalRegistry::Entity.put(
+            global_registry_relationship(type).primary_id_value,
+            relationship_entity,
+            params: {
+              full_response: true,
+              fields: "#{global_registry_relationship(type).related_relationship_name}:relationship"
+            }
+          )
+        rescue RestClient::BadRequest => e
+          response = JSON.parse(e.response.body)
+          raise unless response['error'] =~ /^Validation failed:.*already exists$/i
+          # Delete relationship entity and retry on 400 Bad Request (client_integration_id already exists)
+          delete_relationship_from_global_registry_and_retry
+        end
+
+        def delete_relationship_from_global_registry_and_retry
+          GlobalRegistry::Bindings::Workers::DeleteEntityWorker.new.perform(global_registry_relationship(type).id_value)
+          model.update_column( # rubocop:disable Rails/SkipsModelValidations
+            global_registry_relationship(type).id_column, nil
+          )
+          raise GlobalRegistry::Bindings::RelatedEntityExistsWithCID,
+                "#{model.class.name}(#{model.id}) #{global_registry_relationship(type).related_relationship_name}" \
+                ':relationship already exists with client_integration_id(' \
+                "#{global_registry_relationship(type).client_integration_id}). Will delete and retry."
         end
       end
     end