atlas_engine 0.1.0

data/app/graphql/atlas_engine/schema.rb

@@ -0,0 +1,23 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  class Schema < GraphQL::Schema
+    extend LogHelper
+    query(Types::QueryType)
+
+    class << self
+      def dump
+        schema_path = Pathname.new(__dir__).join("schema.graphql")
+        schema_path.write(to_definition)
+        log_info("Updated GraphQL schema dump: #{schema_path}")
+        true
+      end
+
+      def refresh
+        log_info("Refreshed GraphQL schema types.")
+        true
+      end
+    end
+  end
+end

data/app/graphql/atlas_engine/types/address_validation/address_input.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    module AddressValidation
+      class AddressInput < GraphQL::Schema::InputObject
+        extend T::Sig
+        include LogHelper
+        include AtlasEngine::AddressValidation::AbstractAddress
+
+        description "Address fields used to fulfill a validation request"
+
+        argument :address1, String, required: false
+        argument :address2, String, required: false
+        argument :city, String, required: false
+        argument :country_code, ValidationSupportedCountry, required: false
+        argument :province_code, String, required: false
+        argument :zip, String, required: false
+        argument :phone, String, required: false
+
+        sig { returns(T::Hash[T.untyped, T.untyped]) }
+        def marshal_dump
+          to_kwargs
+        end
+
+        sig { params(hash: T::Hash[T.untyped, T.untyped]).void }
+        def marshal_load(hash)
+          @ruby_style_hash = T.let(hash, T.nilable(T::Hash[T.untyped, T.untyped]))
+        end
+
+        class << self
+          extend T::Sig
+
+          sig do
+            params(hash: T::Hash[Symbol, T.untyped])
+              .returns(AddressInput)
+          end
+          def from_hash(hash)
+            new(
+              nil,
+              ruby_kwargs: hash,
+              context: nil,
+              defaults_used: nil,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/graphql/atlas_engine/types/address_validation/concern_type.rb

@@ -0,0 +1,20 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    module AddressValidation
+      class ConcernType < BaseObject
+        description "A piece of relevant information regarding the address validation result." \
+          "They can be categorized as either a Warning or Error."
+
+        field :field_names, [String], null: false
+        field :message, String, null: false
+        field :code, String, null: false
+        field :type, Enums::ConcernEnum, null: false
+        field :type_level, Int, null: false
+        field :suggestion_ids, [String], null: false
+      end
+    end
+  end
+end

data/app/graphql/atlas_engine/types/address_validation/enums/concern_enum.rb

@@ -0,0 +1,15 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    module AddressValidation
+      module Enums
+        class ConcernEnum < BaseEnum
+          value :WARNING, value: "warning"
+          value :ERROR, value: "error"
+        end
+      end
+    end
+  end
+end

data/app/graphql/atlas_engine/types/address_validation/field_type.rb

@@ -0,0 +1,15 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    module AddressValidation
+      class FieldType < BaseObject
+        description "An individual field which in conjunction with others compose an address"
+
+        field :name, String, null: false
+        field :value, String, null: false
+      end
+    end
+  end
+end

data/app/graphql/atlas_engine/types/address_validation/suggestion_type.rb

@@ -0,0 +1,21 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    module AddressValidation
+      class SuggestionType < BaseObject
+        description "An address-like object containing some value corrections derived during address validation"
+
+        field :id, String, null: false
+        field :address1, String, null: true
+        field :address2, String, null: true
+        field :city, String, null: true
+        field :zip, String, null: true
+        field :province_code, String, null: true
+        field :province, String, null: true
+        field :country_code, ValidationSupportedCountry, null: true
+      end
+    end
+  end
+end

data/app/graphql/atlas_engine/types/base_argument.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class BaseArgument < GraphQL::Schema::Argument
+    end
+  end
+end

data/app/graphql/atlas_engine/types/base_enum.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class BaseEnum < GraphQL::Schema::Enum
+    end
+  end
+end

data/app/graphql/atlas_engine/types/base_field.rb

@@ -0,0 +1,10 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class BaseField < GraphQL::Schema::Field
+      argument_class Types::BaseArgument
+    end
+  end
+end

data/app/graphql/atlas_engine/types/base_input_object.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class BaseInputObject < GraphQL::Schema::InputObject
+    end
+  end
+end

data/app/graphql/atlas_engine/types/base_interface.rb

@@ -0,0 +1,10 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    module BaseInterface
+      include GraphQL::Schema::Interface
+    end
+  end
+end

data/app/graphql/atlas_engine/types/base_object.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class BaseObject < GraphQL::Schema::Object
+    end
+  end
+end

data/app/graphql/atlas_engine/types/base_scalar.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class BaseScalar < GraphQL::Schema::Scalar
+    end
+  end
+end

data/app/graphql/atlas_engine/types/base_union.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class BaseUnion < GraphQL::Schema::Union
+    end
+  end
+end

data/app/graphql/atlas_engine/types/matching_strategy_type.rb

@@ -0,0 +1,12 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class MatchingStrategyType < BaseEnum
+      value :ES, value: "es"
+      value :LOCAL, value: "local"
+      value :ES_STREET, value: "es_street"
+    end
+  end
+end

data/app/graphql/atlas_engine/types/mutation_type.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class MutationType < BaseObject
+    end
+  end
+end

data/app/graphql/atlas_engine/types/query_type.rb

@@ -0,0 +1,61 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class QueryType < Types::BaseObject
+      include LogHelper
+
+      field :validation, ValidationType, null: false do
+        argument :address, AddressValidation::AddressInput, required: true
+        argument :locale, String, required: true
+        argument :matching_strategy, MatchingStrategyType, required: false
+      end
+
+      def validation(address:, locale: "en", matching_strategy: nil)
+        raise build_graphql_error(AtlasEngine::AddressValidation::Errors::MISSING_PARAMETER) if address.blank?
+
+        locale = LocaleFormatHelper.format_locale(locale)
+
+        country_code = address.country_code
+        tags = ["country:#{country_code}", "matching_strategy:#{matching_strategy}"]
+        measure("validation", tags) do
+          I18n.with_locale(locale) do
+            Services::Validation.validate_address(
+              AtlasEngine::AddressValidation::Request.new(
+                address: address,
+                locale: locale,
+                matching_strategy: matching_strategy,
+              ),
+            )
+          end
+        end
+      end
+
+      private
+
+      def measure(method, tags = [], value = nil, &block)
+        if block
+          StatsD.distribution(
+            "#{method}.request_time",
+            tags: tags,
+            &block
+          )
+        else
+          StatsD.distribution(
+            "#{method}.request_time",
+            value,
+            tags: tags,
+          )
+        end
+      end
+
+      def build_graphql_error(error)
+        GraphQL::ExecutionError.new(
+          error.message,
+          extensions: { "error_code" => error.code },
+        )
+      end
+    end
+  end
+end

data/app/graphql/atlas_engine/types/validation_supported_country.rb

@@ -0,0 +1,12 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class ValidationSupportedCountry < BaseEnum
+      Worldwide::Regions.all.select(&:country?).reject(&:deprecated?).map do |country|
+        value country.iso_code, description: country.full_name
+      end
+    end
+  end
+end

data/app/graphql/atlas_engine/types/validation_type.rb

@@ -0,0 +1,22 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Types
+    class ValidationType < BaseObject
+      description "An address validation result object"
+
+      field :id, String, null: false
+      field :fields, [AddressValidation::FieldType], null: false
+      field :validation_scope, [String], null: false
+      field :concerns, [AddressValidation::ConcernType], null: false
+      field :suggestions, [AddressValidation::SuggestionType], null: false
+      field :locale, String, null: false
+      field :candidate,
+        String,
+        null: true,
+        deprecation_reason: "Temporary field meant for internal use only."
+      field :matching_strategy, Types::MatchingStrategyType, null: false
+    end
+  end
+end

data/app/helpers/atlas_engine/address_importer/import_log_helper.rb

@@ -0,0 +1,66 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressImporter
+    module ImportLogHelper
+      extend T::Sig
+      include LogHelper
+
+      TEST_TIMESTAMP = "timestamp"
+
+      sig do
+        params(
+          country_import: CountryImport,
+          message: String,
+          category: T.nilable(Symbol),
+          additional_params: T::Hash[T.untyped, T.untyped],
+          notify: T::Boolean,
+        ).void
+      end
+      def import_log_info(country_import:, message:, category: :progress, additional_params: {}, notify: false)
+        log_info(message, additional_params)
+        event = create_event(country_import, message, category, additional_params)
+        send_notification(event) if event && notify
+      end
+
+      sig do
+        params(
+          country_import: CountryImport,
+          message: String,
+          additional_params: T.nilable(T::Hash[T.untyped, T.untyped]),
+        ).void
+      end
+      def import_log_error(country_import:, message:, additional_params: {})
+        log_error(message, T.must(additional_params))
+        event = create_event(country_import, message, :error, additional_params)
+        send_notification(event) if event
+      end
+
+      private
+
+      sig do
+        params(
+          country_import: CountryImport,
+          message: String,
+          category: T.nilable(Symbol),
+          additional_params: T.nilable(T::Hash[T.untyped, T.untyped]),
+        )
+          .returns(T.nilable(Event))
+      end
+      def create_event(country_import, message, category, additional_params = nil)
+        Event.create(
+          country_import_id: country_import.id,
+          message: message,
+          category: category,
+          additional_params: additional_params.presence,
+        )
+      end
+
+      sig { params(event: Event).void }
+      def send_notification(event)
+        AtlasEngine.address_importer_notifier.constantize.instance.notify(event: event)
+      end
+    end
+  end
+end

data/app/helpers/atlas_engine/application_helper.rb

@@ -0,0 +1,7 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module ApplicationHelper
+  end
+end

data/app/helpers/atlas_engine/locale_format_helper.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module LocaleFormatHelper
+    class << self
+      extend T::Sig
+
+      sig { params(locale: T.nilable(String)).returns(T.nilable(String)) }
+      def format_locale(locale)
+        return if locale.blank?
+
+        resolve_supported_locale(locale) || locale.to_s
+      end
+
+      private
+
+      SUPPORTED_LOCALE_MAP = T.let(
+        {
+          DA: "da",
+          DE: "de",
+          EN: "en",
+          ES: "es",
+          FR: "fr",
+          IT: "it",
+          JA: "ja",
+          NL: "nl",
+          "PT-BR": "pt-BR",
+          PT: "pt",
+        },
+        T::Hash[T.untyped, T.untyped],
+      )
+
+      sig { params(locale: String).returns(T.nilable(String)) }
+      def resolve_supported_locale(locale)
+        SUPPORTED_LOCALE_MAP[locale.to_sym]
+      end
+    end
+  end
+end

data/app/helpers/atlas_engine/log_base.rb

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module LogBase
+    include Kernel
+    extend T::Sig
+
+    TEST_TIMESTAMP = T.let("timestamp", String)
+
+    sig { params(level: Symbol, message: String, additional_params: T::Hash[Symbol, T.untyped]).void }
+    def log_message(level, message, additional_params = {})
+      params = {
+        messages: [{
+          level: level,
+          source: self.class.name,
+          message: message,
+          timestamp: time,
+        }.merge(additional_params)],
+      }
+
+      Rails.logger.send(level, params)
+    end
+
+    sig { returns(String) }
+    def time
+      return TEST_TIMESTAMP if Rails.env.test?
+
+      Time.current.utc.to_fs
+    end
+  end
+end

data/app/helpers/atlas_engine/log_helper.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module LogHelper
+    T.unsafe(self).include(AtlasEngine.log_base.constantize)
+    extend T::Sig
+
+    sig { params(message: String, additional_params: T::Hash[Symbol, T.untyped]).void }
+    def log_info(message, additional_params = {})
+      log_message(:info, message, additional_params)
+    end
+
+    sig { params(message: String, additional_params: T::Hash[Symbol, T.untyped]).void }
+    def log_warn(message, additional_params = {})
+      log_message(:warn, message, additional_params)
+    end
+
+    sig { params(message: String, additional_params: T::Hash[Symbol, T.untyped]).void }
+    def log_error(message, additional_params = {})
+      log_message(:error, message, additional_params)
+    end
+  end
+end

data/app/helpers/atlas_engine/metrics_helper.rb

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module MetricsHelper
+    extend T::Sig
+
+    sig do
+      params(
+        name: String,
+        sample_rate: Float,
+        tags: T::Array[String],
+        block: T.proc.returns(T.untyped),
+      ).returns(T.untyped)
+    end
+    def measure_distribution(name:, sample_rate: 1.0, tags: [], &block)
+      StatsD.distribution(
+        name,
+        sample_rate: sample_rate,
+        tags: tags,
+        &block
+      )
+    end
+  end
+end

data/app/jobs/atlas_engine/address_importer/clear_records_job.rb

@@ -0,0 +1,39 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressImporter
+    class ClearRecordsJob < AddressImporter::ResumableImportJob
+      include ImportLogHelper
+      include LogHelper
+      DELETION_BATCH_SIZE = 2000
+
+      def build_enumerator(params, cursor:)
+        enumerator_builder.build_times_enumerator(1, cursor: cursor)
+      end
+
+      def each_iteration(batch, params)
+        @country_code = params[:country_code]
+        clear_records
+      end
+
+      def clear_records
+        import_log_info(
+          country_import: country_import,
+          message: "Clearing all records from PostAddress where country_code: #{@country_code}...",
+        )
+        rows_deleted = delete_rows
+        rows_deleted = delete_rows until rows_deleted != DELETION_BATCH_SIZE
+        import_log_info(country_import: country_import, message: "PostAddress records cleared.")
+      end
+
+      def delete_rows
+        PostAddress.connection.exec_delete(
+          "DELETE FROM #{PostAddress.table_name} where country_code = '#{@country_code}' LIMIT #{DELETION_BATCH_SIZE}",
+          "DELETE",
+          [],
+        )
+      end
+    end
+  end
+end