partner_api 0.11.2

data/lib/anz_api/endpoints/fetch_jwk.rb

@@ -0,0 +1,35 @@
+require 'anz_api/endpoint'
+
+module AnzApi
+  module Endpoints
+    class FetchJwk < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(request_id: SecureRandom.uuid)
+        @request_id = request_id
+      end
+
+      private
+
+      attr_reader :request_id
+
+      def url
+        config.jwks_url
+      end
+
+      def method
+        'GET'
+      end
+
+      def request_options
+        {
+          headers: combined_headers
+        }
+      end
+
+      def decode(response)
+        response.parse
+      end
+    end
+  end
+end

data/lib/anz_api/failure_response.rb

@@ -0,0 +1,33 @@
+require 'partner_api/errors'
+
+module AnzApi
+  class FailureResponse
+    def initialize(response)
+      @response = response
+    end
+
+    def errors
+      [PartnerApi::Errors::RequestError.new(message: "Invalid Response: #{body}")]
+    end
+
+    def error
+      errors.first
+    end
+
+    def status
+      response.status
+    end
+
+    def body
+      response.body
+    end
+
+    def headers
+      response.headers.to_h
+    end
+
+    private
+
+    attr_reader :response
+  end
+end

data/lib/anz_api.rb

@@ -0,0 +1,15 @@
+require 'dry-configurable'
+require 'logger'
+
+require 'anz_api/client'
+
+module AnzApi
+  extend Dry::Configurable
+
+  setting :logger, default: Logger.new(STDOUT, level: :info)
+  setting :jwks_url, constructor: proc { |value| URI.parse(value) }
+
+  setting :instrumentation, default: -> (action:, tenant_id: nil, &block) { block.call }
+  setting :default_parameters, default: -> { {} }
+  setting :default_headers, default: -> { {} }
+end

data/lib/bnz_api/client.rb

@@ -0,0 +1,45 @@
+require 'bnz_api/endpoints/fetch_id_token'
+require 'bnz_api/endpoints/fetch_jwk'
+
+module BnzApi
+  class Client
+    def self.endpoint(name)
+      define_method(name) do |**args|
+        klass_name = Hanami::Utils::String.classify(name)
+        endpoint_klass = Hanami::Utils::Class.load!("BnzApi::Endpoints::#{klass_name}")
+
+        if config.http_persistent
+          init_endpoint(klass_name, endpoint_klass, **args)
+        else
+          @endpoints = nil
+          endpoint_klass.(config, **args)
+        end
+      end
+    end
+
+    def init_endpoint(klass_name, endpoint_klass, **args)
+      @endpoints ||= {}
+      # TODO: Restructure the code so that we can have
+      # a cleaner implementation of caching here
+      # https://github.com/Kaligo/partner_api/pull/39#discussion_r1758041952
+      if @endpoints[klass_name]
+        @endpoints[klass_name].override_data(**args)
+      else
+        @endpoints[klass_name] = endpoint_klass.new(config, **args)
+      end
+
+      @endpoints[klass_name].call
+    end
+
+    endpoint :fetch_id_token
+    endpoint :fetch_jwk
+
+    def initialize(config: BnzApi.config)
+      @config = config
+    end
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/bnz_api/configuration.rb

@@ -0,0 +1,21 @@
+require 'dry-configurable'
+
+module BnzApi
+  class Configuration
+    include Dry::Configurable
+
+    setting :logger, default: Logger.new(STDOUT, level: :info)
+    setting :token_url, constructor: proc { |value| URI.parse(value) }
+    setting :jwks_url, constructor: proc { |value| URI.parse(value) }
+
+    setting :token_exchange do
+      setting :public_key
+      setting :private_key
+    end
+
+    setting :default_parameters, default: -> { {} }
+    setting :default_headers, default: -> { {} }
+    setting :instrumentation, default: -> (action:, tenant_id: nil, &block) { block.call }
+    setting :http_persistent, default: false
+  end
+end

data/lib/bnz_api/endpoint.rb

@@ -0,0 +1,56 @@
+require 'partner_api/endpoints/base'
+require 'bnz_api/failure_response'
+require 'http'
+require_relative './httpx'
+
+module BnzApi
+  class Endpoint < PartnerApi::Endpoints::Base
+
+    def override_data(_args); end
+
+    private
+
+    def client
+      # TODO: Remove `http_persistent` after the trial is successful
+      @client ||=
+        if config.http_persistent
+          HTTPX.with(debug: config.logger).plugin(:persistent)
+        else
+          HTTP::Client.new(**connection_options)
+                      .use(logging: { logger: config.logger })
+        end
+    end
+
+    def connection_options
+      {}
+    end
+
+    def decode(response)
+      if config.http_persistent
+        JSON.parse(response.body.to_s)
+      else
+        response.parse
+      end
+    end
+
+    def successful?(response)
+      if config.http_persistent
+        response.error.nil?
+      else
+        response.status.success?
+      end
+    end
+
+    def decode_error(response)
+      if config.http_persistent && response.is_a?(HTTPX::ErrorResponse)
+        raise Errors::ConnectionError, response.error.message
+      end
+
+      FailureResponse.new(response)
+    end
+
+    def logging_params
+      { request_id: request_id }
+    end
+  end
+end

data/lib/bnz_api/endpoints/fetch_id_token.rb

@@ -0,0 +1,73 @@
+require 'bnz_api/endpoint'
+
+module BnzApi
+  module Endpoints
+    class FetchIdToken < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(auth_code:, redirect_uri:, client_id:, request_id: SecureRandom.uuid)
+        @auth_code = auth_code
+        @redirect_uri = redirect_uri
+        @client_id = client_id
+        @request_id = request_id
+      end
+
+      def override_data(auth_code:, redirect_uri:, client_id:, request_id: SecureRandom.uuid)
+        @auth_code = auth_code
+        @redirect_uri = redirect_uri
+        @client_id = client_id
+        @request_id = request_id
+      end
+
+      private
+
+      attr_reader :auth_code, :redirect_uri, :client_id, :request_id
+
+      def method
+        'POST'
+      end
+
+      def url
+        config.token_url
+      end
+
+      def headers
+        { 'Content-Type' => 'application/x-www-form-urlencoded' }
+      end
+
+      def request_options
+        { headers: combined_headers, form: parameters }
+      end
+
+      def connection_options
+        super.merge(ssl_options)
+      end
+
+      def api_config
+        config.token_exchange
+      end
+
+      def ssl_options
+        @ssl_options ||=
+          if api_config.public_key && api_config.private_key
+            ssl_context = PartnerApi::Utils::ReadCert
+                            .new(api_config.public_key, api_config.private_key)
+                            .ssl_context
+
+            { ssl_context: ssl_context }
+          else
+            {}
+          end
+      end
+
+      def parameters
+        {
+          'grant_type' => 'authorization_code',
+          'redirect_uri' => redirect_uri,
+          'code' => auth_code,
+          'client_id' => client_id
+        }
+      end
+    end
+  end
+end

data/lib/bnz_api/endpoints/fetch_jwk.rb

@@ -0,0 +1,35 @@
+require 'bnz_api/endpoint'
+
+module BnzApi
+  module Endpoints
+    class FetchJwk < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(request_id: SecureRandom.uuid)
+        @request_id = request_id
+      end
+
+      def override_data(request_id: SecureRandom.uuid)
+        @request_id = request_id
+      end
+
+      private
+
+      attr_reader :request_id
+
+      def url
+        config.jwks_url
+      end
+
+      def method
+        'GET'
+      end
+
+      def request_options
+        {
+          headers: combined_headers
+        }
+      end
+    end
+  end
+end

data/lib/bnz_api/failure_response.rb

@@ -0,0 +1,33 @@
+require 'partner_api/errors'
+
+module BnzApi
+  class FailureResponse
+    def initialize(response)
+      @response = response
+    end
+
+    def errors
+      [PartnerApi::Errors::RequestError.new(message: "Invalid Response: #{body}")]
+    end
+
+    def error
+      errors.first
+    end
+
+    def status
+      response.status
+    end
+
+    def body
+      response.body
+    end
+
+    def headers
+      response.headers.to_h
+    end
+
+    private
+
+    attr_reader :response
+  end
+end

data/lib/bnz_api/httpx.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# NOTE: There is a conflict between `httpx` and `event_tracer`:
+# - `httpx` will load the dependencies of `datadog` gem when the module `Datadog` is defined
+# - Some of our apps use `datadog/statsd` as one of its loggers, which defines `Datadog` module
+# => As a result, there will be LoadError because non of our apps are having `datadog` gem installed
+# Therefore, we use this monkey-patch to skip loading the dependencies of `datadog` gem completely
+# as we are not using that service anyway
+# References:
+#  - https://github.com/HoneyryderChuck/httpx/blob/40b4884d878033b84697d2afb4dfe92425c8e379/lib/httpx.rb#L65
+#  - https://github.com/Kaligo/guardhouse/blob/e11c16f12366012e577832383327c06fe89847a4/config/initializers/event_tracer.rb#L1
+
+require "httpx/version"
+
+require "httpx/extensions"
+
+require "httpx/errors"
+require "httpx/utils"
+require "httpx/punycode"
+require "httpx/domain_name"
+require "httpx/altsvc"
+require "httpx/callbacks"
+require "httpx/loggable"
+require "httpx/transcoder"
+require "httpx/timers"
+require "httpx/pool"
+require "httpx/headers"
+require "httpx/request"
+require "httpx/response"
+require "httpx/options"
+require "httpx/chainable"
+
+# Top-Level Namespace
+#
+module HTTPX
+  EMPTY = [].freeze
+
+  # All plugins should be stored under this module/namespace. Can register and load
+  # plugins.
+  #
+  module Plugins
+    @plugins = {}
+    @plugins_mutex = Thread::Mutex.new
+
+    # Loads a plugin based on a name. If the plugin hasn't been loaded, tries to load
+    # it from the load path under "httpx/plugins/" directory.
+    #
+    def self.load_plugin(name)
+      h = @plugins
+      m = @plugins_mutex
+      unless (plugin = m.synchronize { h[name] })
+        require "httpx/plugins/#{name}"
+        raise "Plugin #{name} hasn't been registered" unless (plugin = m.synchronize { h[name] })
+      end
+      plugin
+    end
+
+    # Registers a plugin (+mod+) in the central store indexed by +name+.
+    #
+    def self.register_plugin(name, mod)
+      h = @plugins
+      m = @plugins_mutex
+      m.synchronize { h[name] = mod }
+    end
+  end
+
+  extend Chainable
+end
+
+require "httpx/session"
+require "httpx/session_extensions"
+
+# load integrations when possible
+require "httpx/adapters/sentry" if defined?(Sentry)
+require "httpx/adapters/webmock" if defined?(WebMock)

data/lib/bnz_api.rb

@@ -0,0 +1,18 @@
+require 'forwardable'
+require 'concurrent-ruby'
+
+require 'bnz_api/client'
+require 'bnz_api/configuration'
+
+module BnzApi
+  extend self
+  extend Forwardable
+
+  @configuration = Concurrent::Hash.new
+
+  def_delegators 'configuration(:default)', :config, :configure
+
+  def configuration(key)
+    @configuration[key] ||= Configuration.new
+  end
+end

data/lib/fab_api/client.rb

@@ -0,0 +1,36 @@
+require 'hanami/utils/string'
+require 'hanami/utils/class'
+
+require 'fab_api/endpoints/deliver_email'
+require 'fab_api/endpoints/deliver_sms'
+require 'fab_api/endpoints/refresh_token'
+require 'fab_api/endpoints/exchange_token'
+require 'fab_api/endpoints/invalidate_token'
+
+module FabApi
+  class Client
+    def self.endpoint(name)
+      define_method(name) do |**args|
+        klass_name = Hanami::Utils::String.classify(name)
+        endpoint_klass = Hanami::Utils::Class.load!("FabApi::Endpoints::#{klass_name}")
+
+        endpoint_klass.(config, **args)
+      end
+    end
+
+    endpoint :deliver_email
+    endpoint :deliver_sms
+
+    endpoint :refresh_token
+    endpoint :exchange_token
+    endpoint :invalidate_token
+
+    def initialize(config: FabApi.config)
+      @config = config
+    end
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/fab_api/configuration.rb

@@ -0,0 +1,26 @@
+require 'dry-configurable'
+
+module FabApi
+  class Configuration
+    include Dry::Configurable
+
+    setting :logger, default: Logger.new(STDOUT, level: :info)
+
+    setting :base_url, constructor: proc { |value| URI.parse(value) }
+
+    setting :proxy_address
+    setting :proxy_port
+    setting :public_key
+    setting :private_key
+
+    setting :default_parameters, default: -> {
+      {
+        "applicationArea": {
+          "transactionDateTime": Time.now.strftime('%F %H:%M:%S%z'),
+        }
+      }
+    }
+    setting :default_headers, default: -> { {} }
+    setting :instrumentation, default: -> (action:, tenant_id: nil, &block) { block.call }
+  end
+end

data/lib/fab_api/endpoint.rb

@@ -0,0 +1,70 @@
+require 'partner_api/endpoints/base'
+require 'fab_api/failure_response'
+
+module FabApi
+  class Endpoint < PartnerApi::Endpoints::Base
+
+    private
+
+    def connection_options
+      options = {}
+
+      if ssl_options.any?
+        options.merge!(ssl_options)
+      end
+
+      if proxy_options.any?
+        options.merge!(proxy: proxy_options)
+      end
+
+      options
+    end
+
+    def proxy_options
+      @proxy_options ||= {
+        proxy_address: config.proxy_address,
+        proxy_port: config.proxy_port ? config.proxy_port.to_i : nil
+      }.compact
+    end
+
+    def ssl_options
+      @ssl_options ||=
+        if config.public_key && config.private_key
+          ssl_context = OpenSSL::SSL::SSLContext.new.tap do |ctx|
+            ctx.ssl_version = :TLSv1_2 # FAB requires TLS v1.2
+
+            ctx.set_params(
+              cert: OpenSSL::X509::Certificate.new(config.public_key),
+              key: OpenSSL::PKey::RSA.new(config.private_key)
+            )
+          end
+
+          { ssl_context: ssl_context }
+        else
+          {}
+        end
+    end
+
+    def default_headers
+      { "Content-Type" => "application/json" }
+    end
+
+    def default_parameters
+      {
+        "applicationArea" => {
+          "senderId" => "ASC",
+          "countryOfOrigin" => "AE"
+        }
+      }
+    end
+
+    def successful?(response)
+      response.status.success? &&
+        response.parse(:json).dig("responseStatus", "status") == "SUCCESS"
+    end
+
+    def decode_error(response)
+      FailureResponse.new(response)
+    end
+  end
+end

data/lib/fab_api/endpoints/deliver_email.rb

@@ -0,0 +1,56 @@
+require 'fab_api/endpoint'
+
+module FabApi
+  module Endpoints
+    class DeliverEmail < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(partner_user_id:, notification_id:, subject:, message:)
+        @partner_user_id = partner_user_id
+        @notification_id = notification_id
+        @subject = subject
+        @message = message
+      end
+
+      private
+
+      attr_reader :partner_user_id, :notification_id, :subject, :message
+
+      def method
+        "POST"
+      end
+
+      def path
+        "/communication/v1/send/email"
+      end
+
+      def parameters
+        {
+          "applicationArea": {
+            "transactionId": notification_id,
+            "correlationId": notification_id
+          },
+          "dataArea": {
+            "customerIdentifier": partner_user_id,
+            "emailSubject": subject,
+            "emailBodyContent": message,
+            "emailBodyContentType": "text/html",
+            "fromAddress": "FAB <donotreply@bankfab.com>",
+            "fromEntityName": "FAB"
+          }
+        }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def decode(_response); end
+
+      def logging_params
+        {
+          transaction_id: notification_id,
+          correlation_id: notification_id,
+          customer_identifier: partner_user_id
+        }
+      end
+    end
+  end
+end

data/lib/fab_api/endpoints/deliver_sms.rb

@@ -0,0 +1,51 @@
+require 'fab_api/endpoint'
+
+module FabApi
+  module Endpoints
+    class DeliverSms < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(partner_user_id:, notification_id:, message:)
+        @partner_user_id = partner_user_id
+        @notification_id = notification_id
+        @message = message
+      end
+
+      private
+
+      attr_reader :partner_user_id, :notification_id, :message
+
+      def method
+        "POST"
+      end
+
+      def path
+        "/communication/v1/send/sms"
+      end
+
+      def parameters
+        {
+          "applicationArea" => {
+            "transactionId" => notification_id,
+            "correlationId" => notification_id
+          },
+          "dataArea" => {
+            "customerIdentifier" => partner_user_id,
+            "messageText" => message,
+            "originatorName" => "FAB"
+          }
+        }
+      end
+
+      def decode(_response); end
+
+      def logging_params
+        {
+          transaction_id: notification_id,
+          correlation_id: notification_id,
+          customer_identifier: partner_user_id
+        }
+      end
+    end
+  end
+end