mailhub-sdk 0.1.0

data/lib/Mailhub/internal/types/utils.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Internal
+    module Types
+      # Utilities for dealing with and checking types
+      module Utils
+        # Wraps a type into a type function
+        #
+        # @param type [Proc, Object]
+        # @return [Proc]
+        def self.wrap_type(type)
+          case type
+          when Proc
+            type
+          else
+            -> { type }
+          end
+        end
+
+        # Resolves a type or type function into a type
+        #
+        # @param type [Proc, Object]
+        # @return [Object]
+        def self.unwrap_type(type)
+          type.is_a?(Proc) ? type.call : type
+        end
+
+        def self.coerce(target, value, strict: false)
+          type = unwrap_type(target)
+
+          case type
+          in Array
+            case value
+            when ::Array
+              return type.coerce(value, strict: strict)
+            when Set, ::Hash
+              return coerce(type, value.to_a)
+            end
+          in Hash
+            case value
+            when ::Hash
+              return type.coerce(value, strict: strict)
+            when ::Array
+              return coerce(type, value.to_h)
+            end
+          in ->(t) { t <= NilClass }
+            return nil
+          in ->(t) { t <= String }
+            case value
+            when String, Symbol, Numeric, TrueClass, FalseClass
+              return value.to_s
+            end
+          in ->(t) { t <= Symbol }
+            case value
+            when Symbol, String
+              return value.to_sym
+            end
+          in ->(t) { t <= Integer }
+            case value
+            when Numeric, String, Time
+              return value.to_i
+            end
+          in ->(t) { t <= Float }
+            case value
+            when Numeric, Time, String
+              return value.to_f
+            end
+          in ->(t) { t <= Model }
+            case value
+            when type
+              return value
+            when ::Hash
+              return type.coerce(value, strict: strict)
+            end
+          in Module
+            case type
+            in ->(t) {
+                 t.singleton_class.included_modules.include?(Enum) ||
+                   t.singleton_class.included_modules.include?(Union)
+               }
+              return type.coerce(value, strict: strict)
+            else
+              value # rubocop:disable Lint/Void
+            end
+          else
+            value # rubocop:disable Lint/Void
+          end
+
+          raise Errors::TypeError, "cannot coerce value of type `#{value.class}` to `#{target}`" if strict
+
+          value
+        end
+
+        def self.symbolize_keys(hash)
+          hash.transform_keys(&:to_sym)
+        end
+
+        # Converts camelCase keys to snake_case symbols
+        # This allows SDK methods to accept both snake_case and camelCase keys
+        # e.g., { refundMethod: ... } becomes { refund_method: ... }
+        #
+        # @param hash [Hash]
+        # @return [Hash]
+        def self.normalize_keys(hash)
+          hash.transform_keys do |key|
+            key_str = key.to_s
+            # Convert camelCase to snake_case
+            snake_case = key_str.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+            snake_case.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/Mailhub/media/client.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Media
+    class Client
+      # @param client [Mailhub::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :search
+      # @option params [String, nil] :sort_by
+      # @option params [String, nil] :sort_direction
+      # @option params [Integer, nil] :page_size
+      # @option params [Integer, nil] :page_index
+      #
+      # @example
+      #   client.media.get_medias
+      #
+      # @return [Mailhub::Types::MediaModelPagedResult]
+      def get_medias(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["search"] = params[:search] if params.key?(:search)
+        query_params["sortBy"] = params[:sort_by] if params.key?(:sort_by)
+        query_params["sortDirection"] = params[:sort_direction] if params.key?(:sort_direction)
+        query_params["pageSize"] = params[:page_size] if params.key?(:page_size)
+        query_params["pageIndex"] = params[:page_index] if params.key?(:page_index)
+
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/media",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Mailhub::Types::MediaModelPagedResult.load(response.body)
+        else
+          error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [void]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.media.upload_media
+      #
+      # @return [Mailhub::Types::MediaModel]
+      def upload_media(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        body = Internal::Multipart::FormData.new
+
+        body.add_part(params[:file].to_form_data_part(name: "file")) if params[:file]
+
+        request = Mailhub::Internal::Multipart::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/media",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Mailhub::Types::MediaModel.load(response.body)
+        else
+          error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :code
+      #
+      # @example
+      #   client.media.get_media(code: "code")
+      #
+      # @return [Mailhub::Types::MediaModel]
+      def get_media(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/media/#{URI.encode_uri_component(params[:code].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Mailhub::Types::MediaModel.load(response.body)
+        else
+          error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Mailhub::Media::Types::UpdateMediaRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :code
+      #
+      # @example
+      #   client.media.update_media(code: "code")
+      #
+      # @return [Mailhub::Types::MediaModel]
+      def update_media(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        request_data = Mailhub::Media::Types::UpdateMediaRequest.new(params).to_h
+        non_body_param_names = %w[code]
+        body = request_data.except(*non_body_param_names)
+
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/media/#{URI.encode_uri_component(params[:code].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Mailhub::Types::MediaModel.load(response.body)
+        else
+          error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :code
+      #
+      # @example
+      #   client.media.delete_media(code: "code")
+      #
+      # @return [untyped]
+      def delete_media(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "v1/media/#{URI.encode_uri_component(params[:code].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :code
+      #
+      # @example
+      #   client.media.download_media(code: "code")
+      #
+      # @return [untyped]
+      def download_media(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/media/#{URI.encode_uri_component(params[:code].to_s)}/download",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+    end
+  end
+end

data/lib/Mailhub/media/types/delete_media_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Media
+    module Types
+      class DeleteMediaRequest < Internal::Types::Model
+        field :code, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Mailhub/media/types/download_media_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Media
+    module Types
+      class DownloadMediaRequest < Internal::Types::Model
+        field :code, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Mailhub/media/types/get_media_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Media
+    module Types
+      class GetMediaRequest < Internal::Types::Model
+        field :code, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Mailhub/media/types/get_medias_request.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Media
+    module Types
+      class GetMediasRequest < Internal::Types::Model
+        field :search, -> { String }, optional: true, nullable: false
+
+        field :sort_by, -> { String }, optional: true, nullable: false, api_name: "sortBy"
+
+        field :sort_direction, -> { String }, optional: true, nullable: false, api_name: "sortDirection"
+
+        field :page_size, -> { Integer }, optional: true, nullable: false, api_name: "pageSize"
+
+        field :page_index, -> { Integer }, optional: true, nullable: false, api_name: "pageIndex"
+      end
+    end
+  end
+end

data/lib/Mailhub/media/types/update_media_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Media
+    module Types
+      class UpdateMediaRequest < Internal::Types::Model
+        field :code, -> { String }, optional: false, nullable: false
+
+        field :original_file_name, -> { String }, optional: true, nullable: false, api_name: "originalFileName"
+      end
+    end
+  end
+end

data/lib/Mailhub/media/types/upload_media_request.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Media
+    module Types
+      class UploadMediaRequest < Internal::Types::Model; end
+    end
+  end
+end

data/lib/Mailhub/message/client.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Message
+    class Client
+      # @param client [Mailhub::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :search
+      # @option params [String, nil] :status
+      # @option params [String, nil] :sort_by
+      # @option params [String, nil] :sort_direction
+      # @option params [Integer, nil] :page_size
+      # @option params [String, nil] :cursor
+      #
+      # @example
+      #   client.message.get_messages
+      #
+      # @return [Mailhub::Types::MessageModelCursorPagedResult]
+      def get_messages(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["search"] = params[:search] if params.key?(:search)
+        query_params["status"] = params[:status] if params.key?(:status)
+        query_params["sortBy"] = params[:sort_by] if params.key?(:sort_by)
+        query_params["sortDirection"] = params[:sort_direction] if params.key?(:sort_direction)
+        query_params["pageSize"] = params[:page_size] if params.key?(:page_size)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/messages",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Mailhub::Types::MessageModelCursorPagedResult.load(response.body)
+        else
+          error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :guid
+      #
+      # @example
+      #   client.message.get_message(guid: "guid")
+      #
+      # @return [Mailhub::Types::MessageModel]
+      def get_message(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/messages/#{URI.encode_uri_component(params[:guid].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Mailhub::Types::MessageModel.load(response.body)
+        else
+          error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :guid
+      #
+      # @example
+      #   client.message.get_message_events(guid: "guid")
+      #
+      # @return [Array[Mailhub::Types::MessageEventModel]]
+      def get_message_events(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/messages/#{URI.encode_uri_component(params[:guid].to_s)}/events",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+
+      # @param request_options [Hash]
+      # @param params [Mailhub::Message::Types::SendMessageRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.message.send_message
+      #
+      # @return [Mailhub::Types::MessageModel]
+      def send_message(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/messages/send",
+          body: Mailhub::Message::Types::SendMessageRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Mailhub::Types::MessageModel.load(response.body)
+        else
+          error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :guid
+      #
+      # @example
+      #   client.message.cancel_message(guid: "guid")
+      #
+      # @return [Mailhub::Types::MessageModel]
+      def cancel_message(request_options: {}, **params)
+        params = Mailhub::Internal::Types::Utils.normalize_keys(params)
+        request = Mailhub::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/messages/#{URI.encode_uri_component(params[:guid].to_s)}/cancel",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Mailhub::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Mailhub::Types::MessageModel.load(response.body)
+        else
+          error_class = Mailhub::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/Mailhub/message/types/cancel_message_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Message
+    module Types
+      class CancelMessageRequest < Internal::Types::Model
+        field :guid, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Mailhub/message/types/get_message_events_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Message
+    module Types
+      class GetMessageEventsRequest < Internal::Types::Model
+        field :guid, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/Mailhub/message/types/get_message_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mailhub
+  module Message
+    module Types
+      class GetMessageRequest < Internal::Types::Model
+        field :guid, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end