whatsapp_sdk 0.3.0 → 0.4.0

data/lib/whatsapp_sdk/resource/media.rb

@@ -1,11 +1,21 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Media
+      extend T::Sig
+
       class InvalidMedia < 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
@@ -16,39 +26,52 @@ module WhatsappSdk
       # Returns media id.
       #
       # @returns id [String].
+      sig { returns(T.nilable(String)) }
       attr_accessor :id
 
-      module Type
-        AUDIO = 'audio'
-        DOCUMENT = 'document'
-        IMAGE = 'image'
-        VIDEO = 'video'
-        STICKER = 'sticker'
+      class Type < T::Enum
+        extend T::Sig
 
-        VALID_TYPES = [AUDIO, DOCUMENT, IMAGE, VIDEO, STICKER].freeze
+        enums do
+          Audio = new('audio')
+          Document = new('document')
+          Image = new('image')
+          Video = new('video')
+          Sticker = new('sticker')
+        end
       end
 
       # @returns type [String]. Valid options ar audio, document, image, video and sticker.
+      sig { returns(Type) }
       attr_accessor :type
 
       # The protocol and URL of the media to be sent. Use only with HTTP/HTTPS URLs.
       # Do not use this field when the message type is set to text.
       #
       # @returns link [String].
+      sig { returns(T.nilable(String)) }
       attr_accessor :link
 
       # Describes the specified document or image media.
       #
       # @returns caption [String].
+      sig { returns(T.nilable(String)) }
       attr_accessor :caption
 
       # Describes the filename for the specific document. Use only with document media.
       #
       # @returns filename [String].
+      sig { returns(T.nilable(String)) }
       attr_accessor :filename
 
+      sig do
+        params(
+          type: T.any(Type, String), id: T.nilable(String), link: T.nilable(String),
+          caption: T.nilable(String), filename: T.nilable(String)
+        ).void
+      end
       def initialize(type:, id: nil, link: nil, caption: nil, filename: nil)
-        @type = type
+        @type = T.let(deserialize_type(type), Type)
         @id = id
         @link = link
         @caption = caption
@@ -56,7 +79,8 @@ module WhatsappSdk
         validate_media
       end
 
-      def to_json(*_args)
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      def to_json
         json = {}
         json[:id] = id unless id.nil?
         json[:link] = link unless link.nil?
@@ -67,15 +91,20 @@ module WhatsappSdk
 
       private
 
+      sig { params(type: T.any(String, Type)).returns(Type) }
+      def deserialize_type(type)
+        return type if type.is_a?(Type)
+
+        Type.deserialize(type)
+      end
+
+      sig { returns(T::Boolean) }
       def validate_media
-        unless Type::VALID_TYPES.include?(type)
-          raise InvalidMedia.new(:type, "invalid type. type should be audio, document, image, video or sticker")
-        end
-        if filename && (type != Type::DOCUMENT)
+        if filename && (type != Type::Document)
           raise InvalidMedia.new(:filename, "filename can only be used with document")
         end
 
-        if caption && !(type == Type::DOCUMENT || type == Type::IMAGE)
+        if caption && !(type == Type::Document || type == Type::Image)
           raise InvalidMedia.new(:caption, "caption can only be used with document or image")
         end
 

data/lib/whatsapp_sdk/resource/message.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Message
+      extend T::Sig
+
+      sig { returns(String) }
       attr_reader :id
 
+      sig { params(id: String).void }
       def initialize(id:)
         @id = id
       end

data/lib/whatsapp_sdk/resource/name.rb

@@ -1,10 +1,36 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Name
-      attr_accessor :formatted_name, :first_name, :last_name, :middle_name, :suffix, :prefix
+      extend T::Sig
 
+      sig { returns(T.nilable(String)) }
+      attr_accessor :formatted_name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :first_name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :last_name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :middle_name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :suffix
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :prefix
+
+      sig do
+        params(
+          formatted_name: T.nilable(String), first_name: T.nilable(String),
+          last_name: T.nilable(String), middle_name: T.nilable(String),
+          suffix: T.nilable(String), prefix: T.nilable(String)
+        ).void
+      end
       def initialize(
         formatted_name: nil, first_name: nil,
         last_name: nil, middle_name: nil, suffix: nil, prefix: nil
@@ -17,6 +43,7 @@ module WhatsappSdk
         @prefix = prefix
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           formatted_name: @formatted_name,

data/lib/whatsapp_sdk/resource/org.rb

@@ -1,16 +1,28 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Org
-      attr_accessor :company, :department, :title
+      extend T::Sig
 
+      sig { returns(String) }
+      attr_accessor :company
+
+      sig { returns(String) }
+      attr_accessor :department
+
+      sig { returns(String) }
+      attr_accessor :title
+
+      sig { params(company: String, department: String, title: String).void }
       def initialize(company:, department:, title:)
         @company = company
         @department = department
         @title = title
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           company: @company,

data/lib/whatsapp_sdk/resource/parameter_object.rb

@@ -1,20 +1,37 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class ParameterObject
+      extend T::Sig
+
       class InvalidType < StandardError
+        extend T::Sig
+
+        sig { returns(String) }
         attr_accessor :message
 
+        sig { params(type: String).void }
         def initialize(type)
-          @message = "invalid type #{type}. type should be text, currency, date_time, image, document or video"
+          @message = T.let(
+            "invalid type #{type}. type should be text, currency, date_time, image, document or video",
+            String
+          )
           super
         end
       end
 
       class MissingValue < StandardError
-        attr_reader :field, :message
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :field
 
+        sig { returns(String) }
+        attr_reader :message
+
+        sig { params(field: String, message: String).void }
         def initialize(field, message)
           @field = field
           @message = message
@@ -25,17 +42,20 @@ module WhatsappSdk
       # Returns the parameter type.
       #
       # @returns type [String] Valid options are text, currency, date_time, image, document, video.
+      sig { returns(Type) }
       attr_accessor :type
 
-      module Type
-        TEXT = "text"
-        CURRENCY = "currency"
-        DATE_TIME = "date_time"
-        IMAGE = "image"
-        DOCUMENT = "document"
-        VIDEO = "video"
+      class Type < T::Enum
+        extend T::Sig
 
-        VALID_TYPES = [TEXT, CURRENCY, DATE_TIME, IMAGE, DOCUMENT, VIDEO].freeze
+        enums do
+          Text = new("text")
+          Currency = new("currency")
+          DateTime = new("date_time")
+          Image = new("image")
+          Document = new("document")
+          Video = new("video")
+        end
       end
 
       # Returns Text string if the parameter object type is text.
@@ -43,35 +63,47 @@ module WhatsappSdk
       # For the body component, the character limit is 1024 characters.
       #
       # @returns text [String]
+      sig { returns(T.nilable(String)) }
       attr_accessor :text
 
       # Returns Currency if the parameter object type is currency.
       #
       # @returns currency [Currency]
+      sig { returns(T.nilable(Currency)) }
       attr_accessor :currency
 
       # Returns date_time if the parameter object type is date_time.
       #
       # @returns date_time [DateTime]
+      sig { returns(T.nilable(DateTime)) }
       attr_accessor :date_time
 
       # Returns image if the parameter object type is image.
       #
       # @returns image [Media]
+      sig { returns(T.nilable(Media)) }
       attr_accessor :image
 
       # Returns document if the parameter object type is document.
       #
       # @returns document [Media]
+      sig { returns(T.nilable(Media)) }
       attr_accessor :document
 
       # Returns video if the parameter object type is video.
       #
       # @returns video [Media]
+      sig { returns(T.nilable(Media)) }
       attr_accessor :video
 
+      sig do
+        params(
+          type: T.any(Type, String), text: T.nilable(String), currency: T.nilable(Currency),
+          date_time: T.nilable(DateTime), image: T.nilable(Media), document: T.nilable(Media), video: T.nilable(Media)
+        ).void
+      end
       def initialize(type:, text: nil, currency: nil, date_time: nil, image: nil, document: nil, video: nil)
-        @type = type
+        @type = T.let(deserialize_type(type), Type)
         @text = text
         @currency = currency
         @date_time = date_time
@@ -81,52 +113,63 @@ module WhatsappSdk
         validate
       end
 
-      def to_json(*_args)
-        json = { type: type }
-        json[type.to_sym] = case type
-                            when "text"
-                              text
-                            when "currency"
-                              currency.to_json
-                            when "date_time"
-                              date_time.to_json
-                            when "image"
-                              image.to_json
-                            when "document"
-                              document.to_json
-                            when "video"
-                              video.to_json
-                            else
-                              raise "Invalid type: #{type}"
-                            end
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      def to_json
+        json = { type: type.serialize }
+        json[type.serialize.to_sym] = case type.serialize
+                                      when "text"
+                                        text
+                                      when "currency"
+                                        T.must(currency).to_json
+                                      when "date_time"
+                                        T.must(date_time).to_json
+                                      when "image"
+                                        T.must(image).to_json
+                                      when "document"
+                                        T.must(document).to_json
+                                      when "video"
+                                        T.must(video).to_json
+                                      else
+                                        raise "Invalid type: #{type}"
+                                      end
 
         json
       end
 
       private
 
+      sig { params(type: T.any(String, Type)).returns(Type) }
+      def deserialize_type(type)
+        return type if type.is_a?(Type)
+
+        Type.deserialize(type)
+      end
+
+      sig { void }
       def validate
         validate_attributes
         validate_type
       end
 
+      sig { void }
       def validate_type
-        return if Type::VALID_TYPES.include?(type)
+        return if Type.valid?(type)
 
         raise InvalidType, type
       end
 
+      sig { void }
       def validate_attributes
         [
-          [:text, text],
-          [:currency, currency],
-          [:date_time, date_time],
-          [:image, image],
-          [:document, document],
-          [:video, video]
-        ].each do |type_sym, value|
-          next unless type == type_sym
-          raise MissingValue.new(type, "#{type} is required when the type is #{type}") if value.nil?
+          [Type::Text, text],
+          [Type::Currency, currency],
+          [Type::DateTime, date_time],
+          [Type::Image, image],
+          [Type::Document, document],
+          [Type::Video, video]
+        ].each do |type_b, value|
+          next unless type == type_b
+          raise MissingValue.new(type.serialize, "#{type_b} is required when the type is #{type_b}") if value.nil?
         end
       end
     end

data/lib/whatsapp_sdk/resource/phone_number.rb

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

data/lib/whatsapp_sdk/resource/url.rb

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

data/lib/whatsapp_sdk.rb

@@ -1,38 +1,24 @@
 # frozen_string_literal: true
+# typed: true
 
-# Configuration
-require_relative "whatsapp_sdk/configuration"
+require "zeitwerk"
 
-# APIs
-require_relative "whatsapp_sdk/api/phone_numbers"
-require_relative "whatsapp_sdk/api/messages"
-require_relative "whatsapp_sdk/api/medias"
-require_relative "whatsapp_sdk/api/client"
+loader = Zeitwerk::Loader.for_gem
+loader.setup
 
-# APIs responses
-require_relative "whatsapp_sdk/api/responses/message_data_response"
-require_relative "whatsapp_sdk/api/responses/phone_number_data_response"
-require_relative "whatsapp_sdk/api/responses/phone_numbers_data_response"
-require_relative "whatsapp_sdk/api/responses/message_error_response"
-require_relative "whatsapp_sdk/api/responses/data_response"
-require_relative "whatsapp_sdk/api/responses/read_message_data_response"
-require_relative "whatsapp_sdk/api/responses/media_data_response"
-require_relative "whatsapp_sdk/api/responses/success_response"
-require_relative "whatsapp_sdk/api/responses/error_response"
+require "sorbet-runtime"
 
-# Resources
-require_relative "whatsapp_sdk/resource/address"
-require_relative "whatsapp_sdk/resource/button_parameter"
-require_relative "whatsapp_sdk/resource/component"
-require_relative "whatsapp_sdk/resource/contact_response"
-require_relative "whatsapp_sdk/resource/contact"
-require_relative "whatsapp_sdk/resource/currency"
-require_relative "whatsapp_sdk/resource/date_time"
-require_relative "whatsapp_sdk/resource/email"
-require_relative "whatsapp_sdk/resource/media"
-require_relative "whatsapp_sdk/resource/message"
-require_relative "whatsapp_sdk/resource/name"
-require_relative "whatsapp_sdk/resource/org"
-require_relative "whatsapp_sdk/resource/parameter_object"
-require_relative "whatsapp_sdk/resource/phone_number"
-require_relative "whatsapp_sdk/resource/url"
+module WhatsappSdk
+  class << self
+    extend T::Sig
+
+    sig { returns(Configuration) }
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/sorbet/config

@@ -0,0 +1,6 @@
+--dir
+.
+--ignore=vendor/
+--ignore=testing.rb
+--ignore=example.rb
+--enable-experimental-requires-ancestor

data/sorbet/rbi/annotations/faraday.rbi

@@ -0,0 +1,17 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Faraday
+  class << self
+    sig { params(url: T.untyped, options: T::Hash[Symbol, T.untyped], block: T.nilable(T.proc.params(connection: Faraday::Connection).void)).returns(Faraday::Connection) }
+    def new(url = nil, options = {}, &block); end
+  end
+end
+
+class Faraday::Response
+  sig { returns(T::Boolean) }
+  def success?; end
+end

data/sorbet/rbi/annotations/mocha.rbi

@@ -0,0 +1,34 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Mocha::API
+  sig { params(arguments: T.untyped).returns(Mocha::Mock) }
+  def mock(*arguments); end
+
+  sig { params(arguments: T.untyped).returns(T.untyped) }
+  def stub(*arguments); end
+end
+
+module Mocha::ClassMethods
+  sig { returns(Mocha::Mock) }
+  def any_instance; end
+end
+
+class Mocha::Expectation
+  sig { params(expected_parameters: T.untyped, matching_block: T.nilable(T.proc.params(actual_parameters: T.untyped).void)).returns(Mocha::Expectation) }
+  def with(*expected_parameters, &matching_block); end
+
+  sig { params(values: T.untyped).returns(Mocha::Expectation) }
+  def returns(*values); end
+end
+
+module Mocha::ObjectMethods
+  sig { params(expected_methods_vs_return_values: T.untyped).returns(Mocha::Expectation) }
+  def expects(expected_methods_vs_return_values); end
+
+  sig { params(stubbed_methods_vs_return_values: T.untyped).returns(Mocha::Expectation) }
+  def stubs(stubbed_methods_vs_return_values); end
+end