whatsapp_sdk 0.3.0 → 0.4.0

data/lib/whatsapp_sdk/api/responses/message_error_response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require_relative "error_response"
 
@@ -6,18 +7,36 @@ module WhatsappSdk
   module Api
     module Responses
       class MessageErrorResponse < ErrorResponse
-        attr_reader :code, :subcode, :message, :type, :data, :fbtrace_id
+        sig { returns(Integer) }
+        attr_reader :code
 
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :subcode
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :message
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :data
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :fbtrace_id
+
+        sig { params(response: T::Hash[T.untyped, T.untyped]).void }
         def initialize(response:)
-          @code = response["code"]
-          @subcode = response["error_subcode"]
-          @message = response["message"]
-          @type = response["type"]
-          @data = response["data"]
-          @fbtrace_id = response["fbtrace_id"]
+          @code = T.let(response["code"], Integer)
+          @subcode = T.let(response["error_subcode"], T.nilable(Integer))
+          @message = T.let(response["message"], T.nilable(String))
+          @type = T.let(response["type"], T.nilable(String))
+          @data = T.let(response["data"], T.nilable(String))
+          @fbtrace_id = T.let(response["fbtrace_id"], T.nilable(String))
           super(response: response)
         end
 
+        sig { override.params(response: T::Hash[T.untyped, T.untyped]).returns(T.nilable(MessageErrorResponse)) }
         def self.build_from_response(response:)
           error_response = response["error"]
           return unless error_response

data/lib/whatsapp_sdk/api/responses/phone_number_data_response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require_relative "data_response"
 
@@ -6,16 +7,28 @@ module WhatsappSdk
   module Api
     module Responses
       class PhoneNumberDataResponse < DataResponse
-        attr_accessor :id, :verified_name, :display_phone_number, :quality_rating
+        sig { returns(String) }
+        attr_accessor :id
 
+        sig { returns(String) }
+        attr_accessor :verified_name
+
+        sig { returns(String) }
+        attr_accessor :display_phone_number
+
+        sig { returns(String) }
+        attr_accessor :quality_rating
+
+        sig { params(response: T::Hash[T.untyped, T.untyped]).void }
         def initialize(response)
-          @id = response["id"]
-          @verified_name = response["verified_name"]
-          @display_phone_number = response["display_phone_number"]
-          @quality_rating = response["quality_rating"]
+          @id = T.let(response["id"], String)
+          @verified_name = T.let(response["verified_name"], String)
+          @display_phone_number = T.let(response["display_phone_number"], String)
+          @quality_rating = T.let(response["quality_rating"], String)
           super(response)
         end
 
+        sig { override.params(response: T::Hash[T.untyped, T.untyped]).returns(T.nilable(PhoneNumberDataResponse)) }
         def self.build_from_response(response:)
           return unless response["id"]
 

data/lib/whatsapp_sdk/api/responses/phone_numbers_data_response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require_relative "data_response"
 require_relative "phone_number_data_response"
@@ -7,13 +8,19 @@ module WhatsappSdk
   module Api
     module Responses
       class PhoneNumbersDataResponse < DataResponse
+        sig { returns(T::Array[PhoneNumberDataResponse]) }
         attr_reader :phone_numbers
 
+        sig { params(response: T::Hash[T.untyped, T.untyped]).void }
         def initialize(response)
-          @phone_numbers = response['data']&.map { |phone_number| parse_phone_number(phone_number) }
+          @phone_numbers = T.let(
+            response['data']&.map { |phone_number| parse_phone_number(phone_number) },
+            T::Array[PhoneNumberDataResponse]
+          )
           super(response)
         end
 
+        sig { override.params(response: T::Hash[T.untyped, T.untyped]).returns(T.nilable(PhoneNumbersDataResponse)) }
         def self.build_from_response(response:)
           return unless response["data"]
 
@@ -22,6 +29,7 @@ module WhatsappSdk
 
         private
 
+        sig { params(phone_number: T::Hash[T.untyped, T.untyped]).returns(PhoneNumberDataResponse) }
         def parse_phone_number(phone_number)
           PhoneNumberDataResponse.new(phone_number)
         end

data/lib/whatsapp_sdk/api/responses/read_message_data_response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require_relative "../request"
 require_relative "data_response"
@@ -9,18 +10,24 @@ module WhatsappSdk
   module Api
     module Responses
       class ReadMessageDataResponse < DataResponse
-        attr_reader :success
-
+        extend T::Sig
+        sig { params(response: T::Hash[T.untyped, T.untyped]).void }
         def initialize(response:)
-          @success = response["success"]
+          @success = T.let(response["success"], T::Boolean)
           super(response)
         end
 
+        sig { override.params(response: T::Hash[T.untyped, T.untyped]).returns(T.nilable(ReadMessageDataResponse)) }
         def self.build_from_response(response:)
           return if response["error"]
 
           new(response: response)
         end
+
+        sig { returns(T::Boolean) }
+        def success?
+          @success
+        end
       end
     end
   end

data/lib/whatsapp_sdk/api/responses/success_response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require_relative "data_response"
 
@@ -6,17 +7,20 @@ module WhatsappSdk
   module Api
     module Responses
       class SuccessResponse < DataResponse
+        sig { params(response: T::Hash[T.untyped, T.untyped]).void }
         def initialize(response:)
-          @success = response["success"]
+          @success = T.let(response["success"], T::Boolean)
           super(response)
         end
 
+        sig { override.params(response: T::Hash[T.untyped, T.untyped]).returns(T.nilable(SuccessResponse)) }
         def self.build_from_response(response:)
           return unless response["success"]
 
           new(response: response)
         end
 
+        sig { returns(T::Boolean) }
         def success?
           @success
         end

data/lib/whatsapp_sdk/configuration.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   # This module allows client instantiating the client as a singleton like the following example:
@@ -7,27 +8,19 @@ module WhatsappSdk
   # end
   #
   # The gem have access to the client through WhatsappSdk.configuration.client
-
-  class << self
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    def configure
-      yield(configuration)
-    end
-  end
-
   class Configuration
+    extend T::Sig
+
+    sig { returns(String) }
     attr_accessor :access_token
 
-    def initialize(access_token = nil)
+    sig { params(access_token: String).void }
+    def initialize(access_token = "")
       @access_token = access_token
     end
 
+    sig { returns(WhatsappSdk::Api::Client) }
     def client
-      return unless access_token
-
       WhatsappSdk::Api::Client.new(access_token)
     end
   end

data/lib/whatsapp_sdk/error.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   class Error < StandardError; end

data/lib/whatsapp_sdk/resource/address.rb

@@ -1,16 +1,39 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Address
-      attr_accessor :street, :city, :state, :zip, :country, :country_code, :typ
+      extend T::Sig
 
-      ADDRESS_TYPE = {
-        home: "HOME",
-        work: "WORK"
-      }.freeze
+      sig { returns(String) }
+      attr_accessor :street
 
-      def initialize(street:, city:, state:, zip:, country:, country_code:, type: ADDRESS_TYPE::HOME)
+      sig { returns(String) }
+      attr_accessor :city
+
+      sig { returns(String) }
+      attr_accessor :state
+
+      sig { returns(String) }
+      attr_accessor :zip
+
+      sig { returns(String) }
+      attr_accessor :country
+
+      sig { returns(String) }
+      attr_accessor :country_code
+
+      sig { returns(AddressType) }
+      attr_accessor :type
+
+      sig do
+        params(
+          street: String, city: String, state: String, zip: String,
+          country: String, country_code: String, type: AddressType
+        ).void
+      end
+      def initialize(street:, city:, state:, zip:, country:, country_code:, type: AddressType::Home)
         @street = street
         @city = city
         @state = state
@@ -20,6 +43,7 @@ module WhatsappSdk
         @type = type
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           street: @street,

data/lib/whatsapp_sdk/resource/address_type.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# typed: strict
+
+module WhatsappSdk
+  module Resource
+    class AddressType < T::Enum
+      extend T::Sig
+
+      enums do
+        Home = new("Home")
+        Work = new("Work")
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/resource/button_parameter.rb

@@ -1,27 +1,24 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class ButtonParameter
-      class InvalidType < StandardError
-        attr_accessor :message
-
-        def initialize(type)
-          @message = "invalid type #{type}. type should be text or payload"
-          super
-        end
-      end
+      extend T::Sig
 
       # Returns the button parameter type.
       #
       # @returns type [String] Valid options are payload and text.
+      sig { returns(Type) }
       attr_accessor :type
 
-      module Type
-        TEXT = "text"
-        PAYLOAD = "payload"
+      class Type < T::Enum
+        extend T::Sig
 
-        VALID_TYPES = [PAYLOAD, TEXT].freeze
+        enums do
+          Text = new("text")
+          Payload = new("payload")
+        end
       end
 
       # Required for quick_reply buttons.
@@ -29,37 +26,36 @@ module WhatsappSdk
       # in addition to the display text on the button.
       #
       # @returns payload [String]
+      sig { returns(T.nilable(String)) }
       attr_accessor :payload
 
       # Required for URL buttons.
       # Developer-provided suffix that is appended to the predefined prefix URL in the template.
       #
       # @returns text [String]
+      sig { returns(T.nilable(String)) }
       attr_accessor :text
 
+      sig do
+        params(
+          type: Type, payload: T.nilable(String), text: T.nilable(String)
+        ).void
+      end
       def initialize(type:, payload: nil, text: nil)
         @type = type
         @payload = payload
         @text = text
-        validate
       end
 
-      def to_json(*_args)
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      def to_json
         json = {
-          type: type
+          type: type.serialize
         }
         json[:payload] = payload if payload
         json[:text] = text if text
         json
       end
-
-      private
-
-      def validate
-        return if Type::VALID_TYPES.include?(type)
-
-        raise InvalidType, type
-      end
     end
   end
 end

data/lib/whatsapp_sdk/resource/component.rb

@@ -1,11 +1,21 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Component
+      extend T::Sig
+
       class InvalidField < StandardError
-        attr_reader :field, :message
+        extend T::Sig
+
+        sig { returns(Symbol) }
+        attr_reader :field
+
+        sig { returns(String) }
+        attr_reader :message
 
+        sig { params(field: Symbol, message: String).void }
         def initialize(field, message)
           @field = field
           @message = message
@@ -13,25 +23,35 @@ module WhatsappSdk
         end
       end
 
-      module Type
-        HEADER = 'header'
-        BODY = 'body'
-        BUTTON = 'button'
+      class Type < T::Enum
+        extend T::Sig
+
+        enums do
+          Header = new("header")
+          Body = new("body")
+          Button = new("button")
+        end
       end
 
-      module Subtype
-        QUICK_REPLY = "quick_reply"
-        URL = "url"
+      class Subtype < T::Enum
+        extend T::Sig
+
+        enums do
+          QuickReply = new("quick_reply")
+          Url = new("url")
+        end
       end
 
       # Returns the Component type.
       #
       # @returns type [String]. Supported Options are header, body and button.
+      sig { returns(Type) }
       attr_accessor :type
 
       # Returns the parameters of the component. For button type, it's required.
       #
       # @returns parameter [Array<ButtonParameter, ParameterObject>] .
+      sig { returns(T::Array[T.any(ButtonParameter, ParameterObject)]) }
       attr_accessor :parameters
 
       # Returns the Type of button to create. Required when type=button. Not used for the other types.
@@ -42,40 +62,52 @@ module WhatsappSdk
       # appending the text parameter to the predefined prefix URL in the template.
       #
       # @returns subtype [String]. Valid options are quick_reply and url.
+      sig { returns(T.nilable(WhatsappSdk::Resource::Component::Subtype)) }
       attr_accessor :sub_type
 
       # Required when type=button. Not used for the other types.
       # Position index of the button. You can have up to 3 buttons using index values of 0 to 2.
       #
       # @returns index [Integer].
+      sig { returns(T.nilable(Integer)) }
       attr_accessor :index
 
+      sig { params(parameter: T.any(ButtonParameter, ParameterObject)).void }
       def add_parameter(parameter)
         @parameters << parameter
       end
 
+      sig do
+        params(
+          type: Type, parameters: T::Array[T.any(ButtonParameter, ParameterObject)],
+          sub_type: T.nilable(WhatsappSdk::Resource::Component::Subtype), index: T.nilable(Integer)
+        ).void
+      end
       def initialize(type:, parameters: [], sub_type: nil, index: nil)
         @parameters = parameters
         @type = type
         @sub_type = sub_type
-        @index = index.nil? && type == Type::BUTTON ? 0 : index
+        @index = index.nil? && type == Type::Button ? 0 : index
         validate_fields
       end
 
-      def to_json(*_args)
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      def to_json
         json = {
-          type: type,
+          type: type.serialize,
           parameters: parameters.map(&:to_json)
         }
-        json[:sub_type] = sub_type if sub_type
+        json[:sub_type] = sub_type&.serialize if sub_type
         json[:index] = index if index
         json
       end
 
       private
 
+      sig { void }
       def validate_fields
-        return if type == Type::BUTTON
+        return if type == Type::Button
+
         raise InvalidField.new(:sub_type, 'sub_type is not required when type is not button') if sub_type
 
         raise InvalidField.new(:index, 'index is not required when type is not button') if index

data/lib/whatsapp_sdk/resource/contact.rb

@@ -1,10 +1,38 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Contact
-      attr_accessor :addresses, :birthday, :emails, :name, :org, :phones, :urls
+      extend T::Sig
 
+      sig { returns(T::Array[Address]) }
+      attr_accessor :addresses
+
+      sig { returns(String) }
+      attr_accessor :birthday
+
+      sig { returns(T::Array[Email]) }
+      attr_accessor :emails
+
+      sig { returns(Name) }
+      attr_accessor :name
+
+      sig { returns(Org) }
+      attr_accessor :org
+
+      sig { returns(T::Array[PhoneNumber]) }
+      attr_accessor :phones
+
+      sig { returns(T::Array[Url]) }
+      attr_accessor :urls
+
+      sig do
+        params(
+          addresses: T::Array[Address], birthday: String, emails: T::Array[Email],
+          name: Name, org: Org, phones: T::Array[PhoneNumber], urls: T::Array[Url]
+        ).void
+      end
       def initialize(addresses:, birthday:, emails:, name:, org:, phones:, urls:)
         @addresses = addresses
         @birthday = birthday
@@ -15,6 +43,7 @@ module WhatsappSdk
         @urls = urls
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           addresses: addresses.map(&:to_h),

data/lib/whatsapp_sdk/resource/contact_response.rb

@@ -1,10 +1,18 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class ContactResponse
-      attr_accessor :input, :wa_id
+      extend T::Sig
 
+      sig { returns(String) }
+      attr_accessor :wa_id
+
+      sig { returns(String) }
+      attr_accessor :input
+
+      sig { params(input: String, wa_id: String).void }
       def initialize(input:, wa_id:)
         @input = input
         @wa_id = wa_id

data/lib/whatsapp_sdk/resource/currency.rb

@@ -1,30 +1,38 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Currency
+      extend T::Sig
+
       # Returns default text if localization fails.
       #
       # @returns fallback_value [String].
+      sig { returns(String) }
       attr_accessor :fallback_value
 
       # Currency code as defined in ISO 4217.
       #
       # @returns code [String].
+      sig { returns(String) }
       attr_accessor :code
 
       # Amount multiplied by 1000.
       #
       # @returns code [Float].
+      sig { returns(T.any(Float, Integer)) }
       attr_accessor :amount
 
+      sig { params(fallback_value: String, code: String, amount: T.any(Float, Integer)).void }
       def initialize(fallback_value:, code:, amount:)
         @fallback_value = fallback_value
         @code = code
         @amount = amount
       end
 
-      def to_json(*_args)
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      def to_json
         {
           fallback_value: fallback_value,
           code: code,

data/lib/whatsapp_sdk/resource/date_time.rb

@@ -1,18 +1,24 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class DateTime
+      extend T::Sig
+
       # Returns default text if localization fails.
       #
       # @returns fallback_value [String].
+      sig { returns(String) }
       attr_accessor :fallback_value
 
+      sig { params(fallback_value: String).void }
       def initialize(fallback_value:)
         @fallback_value = fallback_value
       end
 
-      def to_json(*_args)
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      def to_json
         {
           fallback_value: fallback_value
         }

data/lib/whatsapp_sdk/resource/email.rb

@@ -1,20 +1,24 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Email
-      attr_accessor :email, :type
+      extend T::Sig
 
-      EMAIL_TYPE = {
-        home: "HOME",
-        work: "WORK"
-      }.freeze
+      sig { returns(String) }
+      attr_accessor :email
 
+      sig { returns(AddressType) }
+      attr_accessor :type
+
+      sig { params(email: String, type: AddressType).void }
       def initialize(email:, type:)
         @email = email
         @type = type
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           email: @email,