expo_notifier 0.1.0

data/lib/expo_notifier/request/base.rb

@@ -0,0 +1,162 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'uri'
+require 'stringio'
+require 'zlib'
+
+require_relative '../mapper/base'
+require_relative '../response'
+
+module ExpoNotifier
+  module Request
+    # An abstract class for building and sending requests.
+    # @abstract
+    class Base
+      extend T::Generic
+
+      RequestBody  = type_member(:out) { { upper: Mapper::Base } }
+      ResponseBody = type_member(:out) { { upper: Mapper::Base } }
+
+      Generic = T.type_alias { Base[Mapper::Base, Mapper::Base] }
+
+      ########## ---------- Default config ---------- ##########
+      BASE_URL        = 'https://exp.host'
+      WRITE_TIMEOUT   = 5
+      OPEN_TIMEOUT    = 5
+      READ_TIMEOUT    = 30
+      GZIP_MIN_SIZE = 1024
+      BASE_HEADERS    = {
+        'Content-Type'    => 'application/json',
+        'Accept'          => 'application/json',
+        'Accept-Encoding' => 'gzip, deflate',
+      }.freeze #: Hash[String, String]
+      ########## ------------------------------------ ##########
+
+      class << self
+        #: String
+        attr_accessor :path
+
+        #: singleton(Mapper::Base)
+        attr_accessor :response_class
+      end
+
+      #: String
+      attr_reader :url
+
+      #: RequestBody
+      attr_reader :body
+
+      #: Response[ResponseBody]?
+      attr_reader :response
+
+      #: (
+      #|  RequestBody,
+      #|  ?access_token:       String?,
+      #|  ?faraday_adapter:    Symbol,
+      #|  ?base_url:           String,
+      #|  ?write_timeout:      Integer,
+      #|  ?open_timeout:       Integer,
+      #|  ?read_timeout:       Integer,
+      #|  ?gzip:               bool,
+      #|  ?gzip_min_size:      Integer,
+      #|  ?additional_headers: Hash[String, String]?,
+      #| ) -> void
+      def initialize(
+        body,
+        access_token:       nil,
+        faraday_adapter:    Faraday.default_adapter,
+        base_url:           BASE_URL,
+        write_timeout:      WRITE_TIMEOUT,
+        open_timeout:       OPEN_TIMEOUT,
+        read_timeout:       READ_TIMEOUT,
+        gzip:               true,
+        gzip_min_size:      GZIP_MIN_SIZE,
+        additional_headers: nil
+      )
+        @body               = body
+        @access_token       = access_token
+        @faraday_adapter    = faraday_adapter
+        @url                = URI.join(base_url, self.class.path).to_s #: String
+        @write_timeout      = write_timeout
+        @open_timeout       = open_timeout
+        @read_timeout       = read_timeout
+        @gzip               = gzip
+        @gzip_min_size      = gzip_min_size
+        @additional_headers = additional_headers
+      end
+
+      #: -> Response[ResponseBody]
+      def execute
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        faraday_response = begin
+          faraday_connection.post do |req|
+            req.body = body_to_send
+          end
+        rescue Faraday::Error => e
+          e
+        end
+
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+        @response = Response[ResponseBody].new(self.class.response_class, duration.to_f, faraday_response)
+      end
+
+      #: -> T::Hash[String, String]
+      def headers
+        h = BASE_HEADERS
+        h = h.merge({ 'Content-Encoding' => 'gzip' }) if compress_body?
+        h = h.merge(@additional_headers) if @additional_headers
+        h
+      end
+
+      # String in the JSON format
+      #: -> String
+      def raw_body
+        @raw_body ||= body.to_json
+      end
+
+      # String in the JSON format, compressed with gzip if needed
+      #: -> String
+      def body_to_send
+        return raw_body unless compress_body?
+
+        io = StringIO.new
+        Zlib::GzipWriter.wrap(io) { |gz| gz.write(raw_body) }
+        io.string
+      end
+
+      #: -> bool
+      def compress_body?
+        return false unless @gzip
+
+        raw_body.bytesize >= @gzip_min_size
+      end
+
+      alias body_compressed? compress_body?
+
+      #: -> String?
+      def name = self.class.name&.split('::')&.last
+
+      private
+
+      #: -> Faraday::Connection
+      def faraday_connection
+        Faraday.new(
+          @url,
+          headers: headers,
+          request: {
+            write_timeout: @write_timeout,
+            open_timeout:  @open_timeout,
+            read_timeout:  @read_timeout,
+          },
+        ) do |conn|
+          conn.request :authorization, 'Bearer', @access_token if @access_token
+          conn.adapter @faraday_adapter
+        end
+      end
+
+    end
+  end
+end

data/lib/expo_notifier/request/get_push_notification_receipts.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../mapper/push_receipt_ids'
+require_relative '../mapper/push_receipts'
+
+module ExpoNotifier
+  module Request
+    class GetPushNotificationReceipts < Base
+      RequestBody  = type_member(:out) { { fixed: Mapper::PushReceiptIds } }
+      ResponseBody = type_member(:out) { { fixed: Mapper::PushReceipts } }
+
+      self.path = '/--/api/v2/push/getReceipts'
+      self.response_class = Mapper::PushReceipts
+    end
+  end
+end

data/lib/expo_notifier/request/send_push_notifications.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../mapper/push_messages'
+require_relative '../mapper/push_tickets'
+
+module ExpoNotifier
+  module Request
+    class SendPushNotifications < Base
+      RequestBody  = type_member(:out) { { fixed: Mapper::PushMessages } }
+      ResponseBody = type_member(:out) { { fixed: Mapper::PushTickets } }
+
+      self.path = '/--/api/v2/push/send'
+      self.response_class = Mapper::PushTickets
+
+      # String in the JSON format
+      # We override the raw body to send an array as a main object.
+      #: -> String
+      def raw_body
+        @raw_body ||= ExpoNotifier::Mapper::PushMessage.to_json(body.push_message) #: String?
+      end
+
+    end
+  end
+end

data/lib/expo_notifier/response.rb

@@ -0,0 +1,93 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ExpoNotifier
+  class Response
+    extend T::Generic
+
+    Body = type_member(:out) { { upper: Mapper::Base } }
+
+    #: Integer?
+    attr_reader :status_code
+
+    #: Hash[(String | Symbol), String]?
+    attr_reader :headers
+
+    #: String?
+    attr_reader :raw_body
+
+    #: Float
+    attr_reader :duration
+
+    #: Faraday::Error?
+    attr_reader :communication_error
+
+    #: (singleton(Mapper::Base), Float, (Faraday::Response | Faraday::Error)) -> void
+    def initialize(body_class, duration, faraday_response)
+      if faraday_response.is_a?(Faraday::Response)
+        initialize_with_faraday_response(faraday_response)
+      elsif faraday_response.is_a?(Faraday::Error)
+        @communication_error = faraday_response #: Faraday::Error?
+      end
+      @body_class = body_class
+      @duration   = duration
+    end
+
+    # Response body mapped to Ruby objects.
+    #: -> Body?
+    def body
+      @body ||= parse_response_body #: Body?
+    end
+
+    #: -> String?
+    def communication_error_message
+      return unless communication_error
+
+      "[#{communication_error.class}] => #{T.must(communication_error).message}"
+    end
+
+    #: -> bool
+    def success?
+      @status_code == 200
+    end
+
+    #: -> bool
+    def too_many_requests_error?
+      @status_code == 429
+    end
+
+    #: -> bool
+    def malformed_request_error?
+      @status_code.to_s.start_with?('4') && !too_many_requests_error?
+    end
+
+    #: -> bool
+    def server_error?
+      @status_code.to_s.start_with?('5')
+    end
+
+    #: -> bool
+    def communication_error?
+      !!communication_error
+    end
+
+    private
+
+    #: (Faraday::Response) -> void
+    def initialize_with_faraday_response(faraday_response)
+      @status_code = faraday_response.status  #: Integer?
+      @headers     = faraday_response.headers #: Hash[(String | Symbol), String]?
+      @raw_body    = faraday_response.body    #: String?
+    end
+
+    #: -> Body?
+    def parse_response_body
+      return unless @raw_body
+
+      @body_class.from_json(@raw_body)
+    rescue Shale::ParseError, JSON::ParserError
+      nil
+    end
+
+  end
+end

data/lib/expo_notifier/sorbet_shim.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+begin
+  T::Configuration.default_checked_level = :never
+rescue StandardError
+  puts 'WARN: Sorbet default checked level could not be set!'
+end
+error_handler = ->(error, *_) do
+end
+# Suppresses errors caused by incorrect parameter and return types
+T::Configuration.call_validation_error_handler = error_handler
+# Suppresses errors caused by T.cast, T.let, T.must, etc.
+T::Configuration.inline_type_error_handler = error_handler
+# Suppresses errors caused by incorrect parameter ordering
+T::Configuration.sig_validation_error_handler = error_handler

data/lib/expo_notifier/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ExpoNotifier
+  VERSION = '0.1.0'
+end

data/lib/expo_notifier.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'expo_notifier/sorbet_shim'
+require_relative 'expo_notifier/version'
+require_relative 'expo_notifier/request/send_push_notifications'
+require_relative 'expo_notifier/request/get_push_notification_receipts'
+
+module ExpoNotifier
+  class << self
+    #: (String) -> bool
+    def expo_push_token?(token)
+      return false unless token.is_a?(String)
+
+      ((token.start_with?('ExponentPushToken[') || token.start_with?('ExpoPushToken[')) && token.end_with?(']')) ||
+        token.match?(/\A[a-z\d]{8}-[a-z\d]{4}-[a-z\d]{4}-[a-z\d]{4}-[a-z\d]{12}\z/i)
+    end
+  end
+end

data/sorbet/config

@@ -0,0 +1,6 @@
+--dir
+.
+--enable-experimental-requires-ancestor
+--enable-experimental-rbs-comments
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true