global-registry-bindings 0.0.6 → 0.1.0

data/lib/global_registry_bindings/options/relationship_class_options.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      class RelationshipClassOptions
+        delegate :id_column,
+                 :type,
+                 :push_on,
+                 :client_integration_id,
+                 :primary_association,
+                 :primary_association_class,
+                 :primary_association_foreign_key,
+                 :primary_relationship_name,
+                 :related_association,
+                 :related_association_class,
+                 :related_association_foreign_key,
+                 :related_association_type,
+                 :related_relationship_name,
+                 :related_global_registry_id,
+                 :exclude_fields,
+                 :extra_fields, to: :@options
+
+        def initialize(type, model_class)
+          @model_class = model_class
+          @options = OpenStruct.new model_class._global_registry_bindings_options[:relationships][type]
+        end
+
+        def ensure_relationship_type?
+          @options.ensure_relationship_type.present?
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/options/relationship_instance_options.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      class RelationshipInstanceOptions
+        delegate :id_column,
+                 :push_on,
+                 :primary_association,
+                 :primary_association_class,
+                 :primary_association_foreign_key,
+                 :related_association,
+                 :related_association_class,
+                 :related_association_foreign_key,
+                 to: :@class_options
+
+        def initialize(type, model)
+          @model = model
+          @class_options = model.class.global_registry_relationship(type)
+        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 client_integration_id
+          option = @class_options.client_integration_id
+          case option
+          when Proc
+            option.call(@model)
+          when Symbol
+            @model.send(option, type)
+          end
+        rescue ArgumentError
+          @model.send(option)
+        end
+
+        def primary
+          return @model.send(primary_association) if primary_association.present?
+          @model
+        end
+
+        def primary_class
+          primary_association_class || primary.class
+        end
+
+        def primary_type
+          primary&.global_registry_entity&.type
+        end
+
+        def primary_id_value
+          primary&.global_registry_entity&.id_value
+        end
+
+        def primary_class_is_self?
+          primary_class == @model.class
+        end
+
+        def primary_relationship_name
+          @class_options.primary_relationship_name || primary_type
+        end
+
+        def related
+          @model.send(related_association) if related_association.present?
+        end
+
+        def related_type
+          @class_options.related_association_type || related&.global_registry_entity&.type
+        end
+
+        def related_id_value
+          option = @class_options.related_global_registry_id
+          case option
+          when Proc
+            option.call(@model, type)
+          when Symbol
+            @model.send(option, type)
+          else
+            related&.global_registry_entity&.id_value
+          end
+        end
+
+        def related_relationship_name
+          @class_options.related_relationship_name || related_type
+        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
+
+        def ensure_relationship_type?
+          return false if @class_options.related_global_registry_id.present?
+          @class_options.ensure_relationship_type?
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/options/relationship_options_parser.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      class RelationshipOptionsParser
+        def initialize(model_class)
+          @model_class = model_class
+        end
+
+        def defaults
+          {
+            id_column: :global_registry_id,
+            type: @model_class.name.demodulize.underscore.to_sym,
+            client_integration_id: :id,
+            primary_association: nil,
+            primary_association_class: nil,
+            primary_relationship_name: nil,
+            related_association: nil, related_association_type: nil,
+            related_association_class: nil,
+            related_relationship_name: nil,
+            related_global_registry_id: nil,
+            exclude_fields: %i[id created_at updated_at],
+            extra_fields: {}, ensure_relationship_type: true
+          }.freeze
+        end
+
+        def parse(options_hash = {})
+          merge_defaults(options_hash)
+          update_association_classes
+          update_foreign_keys
+          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[:primary_association_class]
+            @options[:primary_association_class] = if @options[:primary_association]
+                                                     association_class @options[:primary_association]
+                                                   else
+                                                     @model_class
+                                                   end
+          end
+          unless @options[:related_association_class] # rubocop:disable Style/GuardClause
+            @options[:related_association_class] = association_class @options[:related_association]
+          end
+        end
+
+        def update_foreign_keys
+          unless @options[:primary_association_foreign_key]
+            @options[:primary_association_foreign_key] = association_foreign_key @options[:primary_association]
+          end
+          unless @options[:related_association_foreign_key] # rubocop:disable Style/GuardClause
+            @options[:related_association_foreign_key] = association_foreign_key @options[:related_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?
+
+          if @options[:primary_association_foreign_key]
+            @options[:exclude_fields] << @options[:primary_association_foreign_key]
+          end
+          if @options[:related_association_foreign_key] # rubocop:disable Style/GuardClause
+            @options[:exclude_fields] << @options[:related_association_foreign_key]
+          end
+        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

data/lib/global_registry_bindings/railtie.rb

@@ -11,7 +11,8 @@ module GlobalRegistry #:nodoc:
               'GlobalRegistry::Bindings::RecordMissingGlobalRegistryId' => 'ignore',
               'GlobalRegistry::Bindings::EntityMissingMdmId' => 'ignore',
               'GlobalRegistry::Bindings::RelatedEntityMissingGlobalRegistryId' => 'ignore',
-              'GlobalRegistry::Bindings::ParentEntityMissingGlobalRegistryId' => 'ignore'
+              'GlobalRegistry::Bindings::ParentEntityMissingGlobalRegistryId' => 'ignore',
+              'GlobalRegistry::Bindings::RelatedEntityExistsWithCID' => 'ignore'
             )
           end
         end

data/lib/global_registry_bindings/version.rb

@@ -2,6 +2,6 @@
 
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
-    VERSION = '0.0.6'
+    VERSION = '0.1.0'
   end
 end

data/lib/global_registry_bindings/worker.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+require 'sidekiq-unique-jobs'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    class Worker
+      include Sidekiq::Worker
+
+      attr_accessor :model
+      delegate :global_registry_entity, to: :model
+      delegate :global_registry_relationship, to: :model
+
+      def initialize(model = nil)
+        self.model = model
+      end
+
+      def perform(model_class, id)
+        klass = model_class.is_a?(String) ? model_class.constantize : model_class
+        self.model = klass.find(id)
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/workers/{delete_gr_entity_worker.rb → delete_entity_worker.rb}

@@ -1,14 +1,9 @@
 # frozen_string_literal: true
 
-require 'sidekiq'
-require 'sidekiq-unique-jobs'
-require 'global_registry'
-
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
     module Workers #:nodoc:
-      class DeleteGrEntityWorker
-        include Sidekiq::Worker
+      class DeleteEntityWorker < ::GlobalRegistry::Bindings::Worker
         sidekiq_options unique: :until_executed
 
         def perform(global_registry_id)

data/lib/global_registry_bindings/workers/pull_mdm_id_worker.rb

@@ -1,17 +1,23 @@
 # frozen_string_literal: true
 
-require 'sidekiq'
-require 'sidekiq-unique-jobs'
+require 'global_registry_bindings/entity/mdm_methods'
 
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
     module Workers #:nodoc:
-      class PullMdmIdWorker
-        include Sidekiq::Worker
+      def self.mdm_worker_class(model_class)
+        klass = Class.new(PullMdmIdWorker) do
+          sidekiq_options unique: :until_timeout, unique_expiration: model_class.global_registry_entity.mdm_timeout
+        end
+        const_set model_class.global_registry_entity.mdm_worker_class_name, klass
+      end
+
+      class PullMdmIdWorker < ::GlobalRegistry::Bindings::Worker
+        include GlobalRegistry::Bindings::Entity::MdmMethods
 
         def perform(model_class, id)
-          klass = model_class.is_a?(String) ? model_class.constantize : model_class
-          klass.find(id).send(:pull_mdm_id_from_global_registry)
+          super model_class, id
+          pull_mdm_id_from_global_registry
         rescue ActiveRecord::RecordNotFound
           # If the record was deleted after the job was created, swallow it
           return
@@ -19,13 +25,6 @@ module GlobalRegistry #:nodoc:
           Rails.logger.info "GR entity for #{self.class.name} #{id} does not exist; will _not_ retry"
         end
       end
-
-      def self.mdm_worker_class(model_class)
-        klass = Class.new(PullMdmIdWorker) do
-          sidekiq_options unique: :until_timeout, unique_expiration: model_class.global_registry.mdm_timeout
-        end
-        const_set model_class.global_registry.mdm_worker_class_name, klass
-      end
     end
   end
 end

data/lib/global_registry_bindings/workers/push_entity_worker.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'global_registry_bindings/worker'
+require 'global_registry_bindings/entity/entity_type_methods'
+require 'global_registry_bindings/entity/push_entity_methods'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Workers #:nodoc:
+      class PushEntityWorker < GlobalRegistry::Bindings::Worker
+        include GlobalRegistry::Bindings::Entity::EntityTypeMethods
+        include GlobalRegistry::Bindings::Entity::PushEntityMethods
+        sidekiq_options unique: :until_and_while_executing
+
+        def perform(model_class, id)
+          super model_class, id
+          push_entity_to_global_registry
+        rescue ActiveRecord::RecordNotFound # rubocop:disable Lint/HandleExceptions
+          # If the record was deleted after the job was created, swallow it
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/workers/push_relationship_worker.rb

@@ -1,18 +1,28 @@
 # frozen_string_literal: true
 
-require 'sidekiq'
-require 'sidekiq-unique-jobs'
+require 'global_registry_bindings/worker'
+require 'global_registry_bindings/entity/relationship_type_methods'
+require 'global_registry_bindings/entity/push_relationship_methods'
 
 module GlobalRegistry #:nodoc:
   module Bindings #:nodoc:
     module Workers #:nodoc:
-      class PushRelationshipWorker
-        include Sidekiq::Worker
+      class PushRelationshipWorker < GlobalRegistry::Bindings::Worker
+        include GlobalRegistry::Bindings::Entity::RelationshipTypeMethods
+        include GlobalRegistry::Bindings::Entity::PushRelationshipMethods
         sidekiq_options unique: :until_and_while_executing
 
-        def perform(model_class, id)
-          klass = model_class.is_a?(String) ? model_class.constantize : model_class
-          klass.find(id).send(:push_relationship_to_global_registry)
+        attr_accessor :type
+
+        def initialize(model = nil, type = nil)
+          super model
+          self.type = type
+        end
+
+        def perform(model_class, id, type)
+          super model_class, id
+          self.type = type
+          push_relationship_to_global_registry
         rescue ActiveRecord::RecordNotFound # rubocop:disable Lint/HandleExceptions
           # If the record was deleted after the job was created, swallow it
         end

data/spec/acceptance/global_registry_bindings_spec.rb

@@ -11,64 +11,74 @@ RSpec.describe 'GlobalRegistry::Bindings' do
 
   describe 'Options' do
     it 'should have default values for all options' do
-      expect(Default.global_registry.id_column).to be :global_registry_id
-      expect(Default.global_registry.mdm_id_column).to be nil
-      expect(Default.global_registry.parent_association).to be nil
-      expect(Default.global_registry.push_on)
-        .to contain_exactly(:create, :update, :delete)
-      expect(Default.global_registry.mdm_timeout).to eq 1.minute
-      expect(Default.global_registry.type).to be :default
-      expect(Default.global_registry.exclude_fields)
+      expect(Default.global_registry_entity.id_column).to be :global_registry_id
+      expect(Default.global_registry_entity.mdm_id_column).to be nil
+      expect(Default.global_registry_entity.parent_association).to be nil
+      expect(Default.global_registry_entity.push_on)
+        .to contain_exactly(:create, :update, :destroy)
+      expect(Default.global_registry_entity.mdm_timeout).to eq 1.minute
+      expect(Default.global_registry_entity.type).to be :default
+      expect(Default.global_registry_entity.exclude_fields)
         .to contain_exactly(:global_registry_id, :id, :created_at, :updated_at)
-      expect(Default.global_registry.extra_fields).to be_a(Hash).and be_empty
+      expect(Default.global_registry_entity.extra_fields).to be_a(Hash).and be_empty
     end
 
     it 'should parse and set mdm options' do
-      expect(Namespaced::Person.global_registry.id_column).to be :global_registry_id
-      expect(Namespaced::Person.global_registry.mdm_id_column).to be :global_registry_mdm_id
-      expect(Namespaced::Person.global_registry.mdm_timeout).to eq 24.hours
-      expect(Namespaced::Person.global_registry.type).to be :person
-      expect(Namespaced::Person.global_registry.exclude_fields)
-        .to contain_exactly(:global_registry_id, :id, :created_at, :updated_at, :global_registry_mdm_id, :guid)
-      expect(Namespaced::Person.global_registry.extra_fields).to be_a(Hash).and be_empty
+      expect(Namespaced::Person.global_registry_entity.id_column).to be :global_registry_id
+      expect(Namespaced::Person.global_registry_entity.mdm_id_column).to be :global_registry_mdm_id
+      expect(Namespaced::Person.global_registry_entity.mdm_timeout).to eq 24.hours
+      expect(Namespaced::Person.global_registry_entity.type).to be :person
+      expect(Namespaced::Person.global_registry_entity.exclude_fields)
+        .to contain_exactly(:country_of_residence_gr_id, :country_of_residence_id, :country_of_service_gr_id,
+                            :country_of_service_id, :created_at, :global_registry_id, :global_registry_mdm_id,
+                            :guid, :id, :updated_at)
+      expect(Namespaced::Person.global_registry_entity.extra_fields).to be_a(Hash).and be_empty
       expect(GlobalRegistry::Bindings::Workers::PullNamespacedPersonMdmIdWorker.get_sidekiq_options)
         .to include('unique' => :until_timeout, 'unique_expiration' => 24.hours)
     end
 
     it 'should parse and set exclude and extra fields options' do
-      expect(Address.global_registry.id_column).to be :global_registry_id
-      expect(Address.global_registry.mdm_id_column).to be nil
-      expect(Address.global_registry.type).to be :address
-      expect(Address.global_registry.parent_association).to be :person
-      expect(Address.global_registry.exclude_fields)
+      address = build(:address)
+      expect(Address.global_registry_entity.id_column).to be :global_registry_id
+      expect(Address.global_registry_entity.mdm_id_column).to be nil
+      expect(Address.global_registry_entity.type).to be :address
+      expect(Address.global_registry_entity.parent_association).to be :person
+      expect(Address.global_registry_entity.exclude_fields).to be_a Proc
+      expect(address.global_registry_entity.exclude_fields)
         .to contain_exactly(:global_registry_id, :id, :created_at, :updated_at, :person_id, :address1)
-      expect(Address.global_registry.extra_fields)
+      expect(Address.global_registry_entity.extra_fields).to be_a Symbol
+      expect(address.global_registry_entity.extra_fields)
         .to include(line1: :string, postal_code: :string)
     end
 
     it 'should parse and set push_on fields' do
-      expect(Organization.global_registry.id_column).to be :gr_id
-      expect(Organization.global_registry.mdm_id_column).to be nil
-      expect(Organization.global_registry.type).to be :fancy_org
-      expect(Organization.global_registry.parent_association).to be :parent
-      expect(Organization.global_registry.push_on).to be_an(Array).and eq(%i[create delete])
-      expect(Organization.global_registry.exclude_fields)
-        .to contain_exactly(:gr_id, :id, :created_at, :updated_at, :parent_id)
-      expect(Organization.global_registry.extra_fields).to be_a(Hash).and be_empty
+      org = build(:organization)
+      expect(Organization.global_registry_entity.id_column).to be :gr_id
+      expect(Organization.global_registry_entity.mdm_id_column).to be nil
+      expect(Organization.global_registry_entity.type).to be_a Proc
+      expect(org.global_registry_entity.type).to be :fancy_org
+      expect(Organization.global_registry_entity.parent_association).to be :parent
+      expect(Organization.global_registry_entity.push_on).to be_an(Array).and eq(%i[create destroy])
+      expect(Organization.global_registry_entity.exclude_fields).to be_a Symbol
+      expect(org.global_registry_entity.exclude_fields)
+        .to contain_exactly(:gr_id, :id, :created_at, :updated_at, :parent_id, :area_id, :global_registry_area_id)
+      expect(Organization.global_registry_entity.extra_fields).to be_a Proc
+      expect(org.global_registry_entity.extra_fields).to be_a(Hash).and be_empty
     end
 
     it 'should parse and set relationship fields' do
-      expect(Assignment.global_registry.id_column).to be :global_registry_id
-      expect(Assignment.global_registry.mdm_id_column).to be nil
-      expect(Assignment.global_registry.type).to be :assignment
-      expect(Assignment.global_registry.parent_association).to be :person
-      expect(Assignment.global_registry.related_association).to be :organization
-      expect(Assignment.global_registry.parent_relationship_name).to be :person
-      expect(Assignment.global_registry.related_relationship_name).to be :fancy_org
-      expect(Assignment.global_registry.push_on).to be_an(Array).and eq(%i[create update delete])
-      expect(Assignment.global_registry.exclude_fields)
+      person = build(:person)
+      org = build(:organization)
+      assignment = build(:assignment, person: person, organization: org)
+      expect(Assignment.global_registry_relationship(:assignment).id_column).to be :global_registry_id
+      expect(Assignment.global_registry_relationship(:assignment).type).to be :assignment
+      expect(Assignment.global_registry_relationship(:assignment).primary_association).to be :person
+      expect(Assignment.global_registry_relationship(:assignment).related_association).to be :organization
+      expect(assignment.global_registry_relationship(:assignment).primary_relationship_name).to be :person
+      expect(assignment.global_registry_relationship(:assignment).related_relationship_name).to be :fancy_org
+      expect(assignment.global_registry_relationship(:assignment).exclude_fields)
         .to contain_exactly(:global_registry_id, :id, :created_at, :updated_at, :person_id, :organization_id)
-      expect(Assignment.global_registry.extra_fields).to be_a(Hash).and be_empty
+      expect(assignment.global_registry_relationship(:assignment).extra_fields).to be_a(Hash).and be_empty
     end
   end
 end