global-registry-bindings 0.0.1

data/lib/global_registry_bindings/entity/relationship_type_methods.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'global_registry'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Entity #: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
+
+            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']
+            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')]
+          end
+
+          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 relationship_type_cache_key
+            "GlobalRegistry::Bindings::RelationshipType::#{global_registry.parent_type}::" \
+              "#{global_registry.related_type}::#{global_registry.parent_relationship_name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/exceptions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    class RecordMissingGlobalRegistryId < StandardError; end
+    class EntityMissingMdmId < StandardError; end
+    class RelatedEntityMissingGlobalRegistryId < StandardError; end
+  end
+end

data/lib/global_registry_bindings/global_registry_bindings.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+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'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    # Call this in your model to enable and configure Global Registry bindings.
+    #
+    # 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.
+    # * `:push_on`: Array of Active Record lifecycle events used to push changes to Global Registry.
+    #    (default: `[:create, :update, :delete]`)
+    # * `: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`)
+    # * `: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`)
+    # * `: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.
+    # * `:mdm_timeout`: Only pull mdm information at most once every `:mdm_timeout`. (default: `1.minute`)
+    #
+    # @api public
+    def global_registry_bindings(options = {})
+      global_registry_bindings_parse_options! options
+
+      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
+      end
+
+      include Entity::DeleteEntityMethods if global_registry.push_on.include? :delete
+      include Entity::MdmMethods if global_registry.mdm_id_column.present?
+    end
+
+    private
+
+    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)
+    end
+  end
+end

data/lib/global_registry_bindings/options.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'global_registry_bindings/options/instance_options'
+require 'global_registry_bindings/options/class_options'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      extend ActiveSupport::Concern
+
+      included do
+        @_global_registry_bindings_class_options ||= GlobalRegistry::Bindings::Options::ClassOptions.new(self)
+      end
+
+      def global_registry
+        @_global_registry_bindings_instance_options ||= GlobalRegistry::Bindings::Options::InstanceOptions.new(self)
+      end
+
+      module ClassMethods
+        def global_registry
+          @_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,
+          related_association: 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
+        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
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/options/class_options.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      class ClassOptions
+        delegate :id_column,
+                 :mdm_id_column,
+                 :mdm_timeout,
+                 :type,
+                 :push_on,
+                 :parent_association,
+                 :related_association,
+                 :parent_relationship_name,
+                 :related_relationship_name,
+                 :exclude_fields,
+                 :extra_fields, to: :@options
+
+        def initialize(model_class)
+          @model_class = model_class
+          @options = OpenStruct.new model_class._global_registry_bindings_options_hash
+        end
+
+        def parent_class
+          return if parent_association.blank?
+          @model_class.reflect_on_all_associations
+                      .detect { |a| a.name == parent_association.to_sym }
+              &.klass
+        end
+
+        def related_class
+          return if related_association.blank?
+          @model_class.reflect_on_all_associations
+                      .detect { |a| a.name == related_association.to_sym }
+            &.klass
+        end
+
+        def parent_is_self?
+          parent_association.present? && parent_type == type
+        end
+
+        def parent_type
+          parent_class&.global_registry&.type
+        end
+
+        def related_type
+          related_class&.global_registry&.type
+        end
+
+        def mdm_worker_class_name
+          "Pull#{@model_class.name.tr(':', '')}MdmIdWorker"
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/options/instance_options.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Options
+      class InstanceOptions
+        delegate :id_column,
+                 :mdm_id_column,
+                 :mdm_timeout,
+                 :type,
+                 :push_on,
+                 :parent_association,
+                 :related_association,
+                 :exclude_fields,
+                 :extra_fields,
+                 :parent_class,
+                 :related_class,
+                 :parent_type,
+                 :related_type,
+                 :parent_relationship_name,
+                 :related_relationship_name,
+                 :parent_is_self?,
+                 :mdm_worker_class_name,
+                 to: :@class_options
+
+        def initialize(model)
+          @model = model
+          @class_options = model.class.global_registry
+        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 parent
+          @model.send(parent_association) if parent_association.present?
+        end
+
+        def related
+          @model.send(related_association) if related_association.present?
+        end
+
+        def parent_id_value
+          parent&.global_registry&.id_value
+        end
+
+        def related_id_value
+          related&.global_registry&.id_value
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    class Railtie < Rails::Railtie
+      initializer 'global_registry_bindings_railtie.configure_rollbar' do
+        if Module.const_defined? :Rollbar
+          ::Rollbar.configure do |config|
+            config.exception_level_filters.merge!(
+              'GlobalRegistry::Bindings::RecordMissingGlobalRegistryId' => 'ignore',
+              'GlobalRegistry::Bindings::EntityMissingMdmId' => 'ignore',
+              'GlobalRegistry::Bindings::RelatedEntityMissingGlobalRegistryId' => 'ignore'
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    VERSION = '0.0.1'
+  end
+end

data/lib/global_registry_bindings/workers/delete_gr_entity_worker.rb

@@ -0,0 +1,22 @@
+# 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
+        sidekiq_options unique: :until_executed
+
+        def perform(global_registry_id)
+          GlobalRegistry::Entity.delete(global_registry_id)
+        rescue RestClient::ResourceNotFound # rubocop:disable Lint/HandleExceptions
+          # If the record doesn't exist, we don't care
+        end
+      end
+    end
+  end
+end

data/lib/global_registry_bindings/workers/pull_mdm_id_worker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+require 'sidekiq-unique-jobs'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Workers #:nodoc:
+      class PullMdmIdWorker
+        include Sidekiq::Worker
+
+        def perform(model_class, id)
+          model_class.find(id).send(:pull_mdm_id_from_global_registry)
+        rescue ActiveRecord::RecordNotFound
+          # If the record was deleted after the job was created, swallow it
+          return
+        rescue RestClient::ResourceNotFound
+          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_gr_entity_worker.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+require 'sidekiq-unique-jobs'
+
+module GlobalRegistry #:nodoc:
+  module Bindings #:nodoc:
+    module Workers #:nodoc:
+      class PushGrEntityWorker
+        include Sidekiq::Worker
+        sidekiq_options unique: :until_and_while_executing
+
+        def perform(model_class, id)
+          model_class.find(id).send(: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