atlas_engine 0.1.0

data/app/models/atlas_engine/address_validation/concern.rb

@@ -0,0 +1,74 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    class Concern
+      extend T::Sig
+
+      TYPES = T.let(
+        {
+          warning: "warning",
+          error: "error",
+        }.freeze,
+        T::Hash[Symbol, String],
+      )
+
+      sig { returns(Symbol) }
+      attr_reader :code
+
+      sig { returns(String) }
+      attr_reader :message
+
+      sig { returns(String) }
+      attr_reader :type
+
+      sig { returns(Integer) }
+      attr_reader :type_level
+
+      sig { returns(T::Array[String]) }
+      attr_reader :suggestion_ids
+
+      sig { returns(T::Array[Symbol]) }
+      attr_reader :field_names
+
+      sig { returns(T.nilable(Suggestion)) }
+      attr_reader :suggestion
+
+      alias_attribute :component_names, :field_names
+
+      sig do
+        params(
+          code: Symbol,
+          message: String,
+          type: String,
+          type_level: Integer,
+          suggestion_ids: T::Array[String],
+          field_names: T::Array[Symbol],
+          suggestion: T.nilable(Suggestion),
+        ).void
+      end
+      def initialize(code:, message:, type:, type_level:, suggestion_ids:, field_names:, suggestion: nil)
+        @code = code
+        @type = type
+        @type_level = type_level
+        @suggestion_ids = suggestion_ids
+        @field_names = field_names
+        @message = message
+        @suggestion = T.let(suggestion, T.nilable(Suggestion))
+      end
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def attributes
+        {
+          field_names: field_names,
+          message: message,
+          code: code,
+          type: type,
+          type_level: type_level,
+          suggestion_ids: suggestion_ids,
+        }
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/concern_producer.rb

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    class ConcernProducer
+      class << self
+        extend T::Sig
+
+        sig { params(result: Result, context: Hash).void }
+        def add(result, context = {})
+          return if result.concerns.empty?
+
+          ConcernQueue.instance.queue.push(ConcernRecord.from_result(result, context))
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/concern_queue.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    class ConcernQueue
+      extend T::Sig
+      include Singleton
+
+      sig { returns(Queue) }
+      attr_reader :queue
+
+      sig { void }
+      def initialize
+        super
+        @queue = T.let(Queue.new, Queue)
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/concern_record.rb

@@ -0,0 +1,122 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    class ConcernRecord
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :address1
+
+      sig { returns(String) }
+      attr_reader :address2
+
+      sig { returns(String) }
+      attr_reader :city
+
+      sig { returns(String) }
+      attr_reader :country_code
+
+      sig { returns(String) }
+      attr_reader :province_code
+
+      sig { returns(String) }
+      attr_reader :zip
+
+      sig { returns(String) }
+      attr_reader :phone
+
+      sig { returns(Result) }
+      attr_reader :result
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :version
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :request_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :client_request_id
+
+      sig { returns(Time) }
+      attr_reader :timestamp
+
+      sig { returns(String) }
+      attr_reader :origin
+
+      class << self
+        extend T::Sig
+
+        sig { params(result: Result, context: T::Hash[T.untyped, T.untyped]).returns(ConcernRecord) }
+        def from_result(result, context = {})
+          new(
+            **T.unsafe(
+              {
+                result: result,
+                **result.address,
+                **context.except(:client_request_id),
+              },
+            ),
+          )
+        end
+      end
+
+      sig do
+        params(
+          request_id: T.nilable(String),
+          timestamp: Time,
+          origin: String,
+          address1: String,
+          address2: String,
+          city: String,
+          province_code: String,
+          country_code: String,
+          zip: String,
+          phone: String,
+          result: Result,
+        ).void
+      end
+      def initialize(
+        request_id: nil,
+        timestamp: Time.zone.now,
+        origin: "",
+        address1: "",
+        address2: "",
+        city: "",
+        province_code: "",
+        country_code: "",
+        zip: "",
+        phone: "",
+        result: Result.new
+      )
+        @request_id = request_id
+        @client_request_id = T.let(result.client_request_id, T.nilable(String))
+        @timestamp = timestamp
+        @origin = origin
+        @address1 = address1
+        @address2 = address2
+        @city = city
+        @province_code = province_code
+        @country_code = country_code
+        @zip = zip
+        @phone = phone
+        @result = result
+        @version = T.let(Rails.configuration.version, T.nilable(String))
+      end
+
+      sig { returns(T::Hash[Symbol, String]) }
+      def address_attributes
+        {
+          address1: address1,
+          address2: address2,
+          city: city,
+          province_code: province_code,
+          zip: zip,
+          country_code: country_code,
+          phone: phone,
+        }
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/datastore_base.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module DatastoreBase
+      extend T::Sig
+      extend T::Helpers
+      interface!
+
+      sig { abstract.returns(Token::Sequence) }
+      def fetch_city_sequence; end
+
+      sig { abstract.returns(T::Array[Token::Sequence]) }
+      def fetch_street_sequences; end
+
+      sig { abstract.returns(T::Array[Candidate]) }
+      def fetch_full_address_candidates; end
+
+      sig { abstract.returns(T::Hash[T.untyped, T.untyped]) }
+      def validation_response; end
+
+      sig { abstract.returns(ValidationTranscriber::AddressParsings) }
+      def parsings; end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/errors.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    class Errors < AtlasEngine::CodedErrors
+      HTTP_ISSUE = T.let(error(:http_issue, "There was an issue processing the request."), CodedError)
+      REQUEST_ISSUE = T.let(error(:request_issue, "There is an error with the given request."), CodedError)
+      MISSING_PARAMETER =
+        T.let(error(:missing_parameter, "The given request is missing a required parameter."), CodedError)
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/es/candidate_selector.rb

@@ -0,0 +1,70 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Es
+      class CandidateSelector
+        include LogHelper
+        extend T::Sig
+
+        sig { params(datastore: DatastoreBase, address: AbstractAddress).void }
+        def initialize(datastore:, address:)
+          @datastore = T.let(datastore, DatastoreBase)
+          @address = T.let(address, AbstractAddress)
+        end
+
+        sig { returns(Concurrent::Promises::Future) }
+        def best_candidate_async
+          Concurrent::Promises.future do
+            best_candidate
+          end
+        end
+
+        sig { returns(T.nilable(CandidateTuple)) }
+        def best_candidate
+          street_sequences_future = datastore.fetch_street_sequences_async
+          city_sequences_future = datastore.fetch_city_sequence_async
+          sorted_candidates.first
+        ensure
+          # We want our futures to complete even when we do not consume their value.
+          street_sequences_future&.wait!
+          city_sequences_future&.wait!
+        end
+
+        private
+
+        attr_reader :datastore, :address
+
+        sig { returns(T::Array[CandidateTuple]) }
+        def sorted_candidates
+          sorted_candidate_tuples = datastore.fetch_full_address_candidates
+            .filter_map.with_index(1) do |candidate, position|
+              address_comparison = AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison.new(
+                address: address,
+                candidate: candidate,
+                datastore: datastore,
+              )
+              tuple = CandidateTuple.new(address_comparison, position, candidate)
+              tuple if tuple.address_comparison.potential_match?
+            end.sort
+
+          emit_sorted_candidates(sorted_candidate_tuples)
+          sorted_candidate_tuples
+        end
+
+        sig { params(sorted_candidate_tuples: T::Array[CandidateTuple]).void }
+        def emit_sorted_candidates(sorted_candidate_tuples)
+          log_info("Sorted candidates:\n #{sorted_candidate_tuples.map { |tuple| tuple.candidate.serialize }}")
+
+          initial_position_top_candidate = sorted_candidate_tuples.first&.position || 0
+          StatsD.distribution(
+            "AddressValidation.query.initial_position_top_candidate",
+            initial_position_top_candidate,
+            tags: { position: initial_position_top_candidate },
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/es/data_mappers/decompounding_data_mapper.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Es
+      module DataMappers
+        class DecompoundingDataMapper < DefaultDataMapper
+          sig do
+            override.returns(T::Hash[Symbol, T.untyped])
+          end
+          def map_data
+            super.tap do |data|
+              decompounded_fields.each do |field|
+                data["#{field}_decompounded".to_sym] = decompound(field: field, value: data[field])
+              end
+            end
+          end
+
+          private
+
+          sig { returns(T::Array[Symbol]) }
+          def decompounded_fields
+            country_profile.attributes.dig("decompounding_patterns").keys.map(&:to_sym)
+          end
+
+          sig { params(field: Symbol, value: T.nilable(String)).returns(T.nilable(String)) }
+          def decompound(field:, value:)
+            FieldDecompounder.new(
+              field: field,
+              value: value,
+              country_profile: country_profile,
+            ).call
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/es/data_mappers/default_data_mapper.rb

@@ -0,0 +1,110 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Es
+      module DataMappers
+        class DefaultDataMapper
+          extend T::Sig
+          include LogHelper
+
+          sig { returns(CountryRepository::PostAddressData) }
+          attr_reader :post_address
+
+          sig { returns(String) }
+          attr_reader :locale
+
+          sig do
+            params(
+              post_address: CountryRepository::PostAddressData,
+              country_profile: CountryProfile,
+              locale: String,
+            ).void
+          end
+          def initialize(post_address:, country_profile:, locale: "")
+            @post_address = post_address
+            @country_profile = country_profile
+            @locale = T.let((locale.empty? ? post_address[:locale] : locale), String)
+          end
+
+          sig do
+            returns(T::Hash[Symbol, T.untyped])
+          end
+          def map_data
+            {}.tap do |data|
+              data.update(
+                post_address
+                  .slice(:id, :locale, :country_code, :province_code, :region1, :region2, :region3, :region4)
+                  .deep_symbolize_keys,
+              )
+              data[:city_aliases] = city_aliases(post_address[:city])
+              data[:suburb] = post_address[:suburb]
+              data[:zip] = Worldwide::Zip.normalize(
+                country_code: post_address[:country_code],
+                zip: post_address[:zip],
+              )
+              data[:street] = post_address[:street]
+              data[:street_stripped] = street_stripped(post_address[:street])
+              data[:street_decompounded] = nil
+              data[:building_and_unit_ranges] = JSON.generate(post_address[:building_and_unit_ranges])
+              data[:approx_building_ranges] = approx_building_ranges(post_address[:building_and_unit_ranges]&.keys)
+              data.update(
+                post_address.slice(:building_name, :latitude, :longitude).deep_symbolize_keys,
+              )
+              data[:location] = {
+                lat: post_address[:latitude],
+                lon: post_address[:longitude],
+              }
+            end
+          end
+
+          protected
+
+          sig { returns(CountryProfile) }
+          attr_reader :country_profile
+
+          sig { params(cities: T::Array[String]).returns(T::Array[T::Hash[Symbol, String]]) }
+          def city_aliases(cities)
+            cities.map do |city|
+              {
+                alias: city,
+              }
+            end
+          end
+
+          sig { params(street: T.nilable(String)).returns(T.nilable(String)) }
+          def street_stripped(street)
+            return if street.blank?
+
+            Street.new(street: street).with_stripped_name
+          end
+
+          sig { params(ranges: T.nilable(T::Array[String])).returns(T.nilable(T::Array[T::Hash[String, Integer]])) }
+          def approx_building_ranges(ranges)
+            return unless ranges
+
+            numeric_ranges = ranges.filter_map do |range_str|
+              AddressNumberRange.new(range_string: range_str).approx_numeric_range
+            end
+            merged_ranges = AddressNumberRange.merge_overlapping_ranges(numeric_ranges)
+            merged_ranges.map { |range| es_integer_range(min: range.min, max: range.max) }
+          rescue AddressNumberRange::RangeError => e
+            log_warn("[#{e.class}]: #{e.message}")
+            nil
+          end
+
+          sig { params(min: Integer, max: Integer).returns(T::Hash[String, Integer]) }
+          def es_integer_range(min:, max:)
+            { "gte" => min, "lte" => max }
+          end
+
+          sig { returns(String) }
+          def locale_language_code
+            Worldwide.locale(code: locale).language_subtag
+          end
+        end
+      end
+    end
+  end
+end