apimatic_core 0.1.0

data/lib/apimatic-core/http/request/http_request.rb

@@ -0,0 +1,50 @@
+module CoreLibrary
+  # An http request.
+  class HttpRequest
+    attr_accessor :http_method, :query_url, :headers,
+                  :parameters, :username, :password,
+                  :context
+
+    # The constructor.
+    # @param [HttpMethodEnum] http_method The HTTP method.
+    # @param [String] query_url The URL to send the request to.
+    # @param [Hash, Optional] headers The headers for the HTTP Request.
+    # @param [Hash, Optional] parameters The parameters for the HTTP Request.
+    # @param [Hash, Optional] context The context for the HTTP Request.
+    def initialize(http_method,
+                   query_url,
+                   headers: {},
+                   parameters: {},
+                   context: {})
+      @http_method = http_method
+      @query_url = query_url
+      @headers = headers
+      @parameters = parameters
+      @context = context
+    end
+
+    # Add a header to the HttpRequest.
+    # @param [String] name The name of the header.
+    # @param [String] value The value of the header.
+    def add_header(name, value)
+      @headers[name] = value
+    end
+
+    # Add a parameter to the HttpRequest.
+    # @param [String] name The name of the parameter.
+    # @param [String] value The value of the parameter.
+    def add_parameter(name, value)
+      @parameters[name] = value
+    end
+
+    # Add a query parameter to the HttpRequest.
+    # @param [String] name The name of the query parameter.
+    # @param [String] value The value of the query parameter.
+    def add_query_parameter(name, value)
+      @query_url = ApiHelper.append_url_with_query_parameters(@query_url,
+                                                              { name => value },
+                                                              ArraySerializationFormat::INDEXED)
+      @query_url = ApiHelper.clean_url(@query_url)
+    end
+  end
+end

data/lib/apimatic-core/http/response/api_response.rb

@@ -0,0 +1,35 @@
+# Http response received.
+module CoreLibrary
+  # The class to hold the complete HTTP response.
+  class ApiResponse
+    attr_reader :status_code, :reason_phrase, :headers, :raw_body, :request,
+                :data, :errors
+
+    # The constructor
+    # @param [HttpResponse] The original, raw response from the api.
+    # @param [Object] The data field specified for the response.
+    # @param [Array<String>] Any errors returned by the server.
+
+    def initialize(http_response,
+                   data: nil,
+                   errors: nil)
+      @status_code = http_response.status_code
+      @reason_phrase = http_response.reason_phrase
+      @headers = http_response.headers
+      @raw_body = http_response.raw_body
+      @request = http_response.request
+      @data = data
+      @errors = errors
+    end
+
+    # Returns true if status_code is between 200-300
+    def success?
+      status_code >= 200 && status_code < 300
+    end
+
+    # Returns true if status_code is between 400-600
+    def error?
+      status_code >= 400 && status_code < 600
+    end
+  end
+end

data/lib/apimatic-core/http/response/http_response.rb

@@ -0,0 +1,24 @@
+module CoreLibrary
+  # Http response received.
+  class HttpResponse
+    attr_reader :status_code, :reason_phrase, :headers, :raw_body, :request
+
+    # The constructor
+    # @param [Integer] status_code The status code returned by the server.
+    # @param [String] reason_phrase The reason phrase returned by the server.
+    # @param [Hash] headers The headers sent by the server in the response.
+    # @param [String] raw_body The raw body of the response.
+    # @param [HttpRequest] request The request that resulted in this response.
+    def initialize(status_code,
+                   reason_phrase,
+                   headers,
+                   raw_body,
+                   request)
+      @status_code = status_code
+      @reason_phrase = reason_phrase
+      @headers = headers
+      @raw_body = raw_body
+      @request = request
+    end
+  end
+end

data/lib/apimatic-core/logger/endpoint_logger.rb

@@ -0,0 +1,28 @@
+module CoreLibrary
+  # This class is responsible for logging info messages, debug messages, and errors.
+  class EndpointLogger
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    # Logs the info message.
+    # @param [String] info_message The message to be logged.
+    def info(info_message)
+      @logger&.info(info_message)
+    end
+
+    # Logs the debug message.
+    # @param [String] debug_message The message to be logged.
+    def debug(debug_message)
+      @logger&.debug(debug_message)
+    end
+
+    # Logs the error.
+    # @param [Exception] error The exception to be logged.
+    def error(error)
+      @logger&.error(error)
+    end
+  end
+end

data/lib/apimatic-core/request_builder.rb

@@ -0,0 +1,361 @@
+module CoreLibrary
+  # This class is the builder of the http request for an API call.
+  class RequestBuilder
+    def initialize
+      @server = nil
+      @path = nil
+      @http_method = nil
+      @template_params = {}
+      @header_params = {}
+      @query_params = {}
+      @form_params = {}
+      @additional_form_params = {}
+      @additional_query_params = {}
+      @multipart_params = {}
+      @body_param = nil
+      @should_wrap_body_param = nil
+      @body_serializer = nil
+      @auth = nil
+      @array_serialization_format = ArraySerializationFormat::INDEXED
+      @xml_attributes = nil
+      @endpoint_name_for_logging = nil
+      @endpoint_logger = nil
+      @template_validation_array = []
+    end
+
+    # The setter for the server.
+    # @param [string] server The server to use for the API call.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def server(server)
+      @server = server
+      self
+    end
+
+    # The setter for the URI of the endpoint.
+    # @param [string] path The URI of the endpoint.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def path(path)
+      @path = path
+      self
+    end
+
+    # The setter for the http method of the request.
+    # @param [HttpMethod] http_method The http method of the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def http_method(http_method)
+      @http_method = http_method
+      self
+    end
+
+    # The setter for the template parameter of the request.
+    # @param [Parameter] template_param The template parameter of the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def template_param(template_param)
+      template_param.validate
+      conditional_add_to_template_validation_array(template_param)
+      @template_params[template_param.get_key] = {  'value' => template_param.get_value,
+                                                    'encode' => template_param.need_to_encode }
+      self
+    end
+
+    # The setter for the header parameter to be sent in the request.
+    # @param [Parameter] header_param The header parameter to be sent in the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def header_param(header_param)
+      header_param.validate
+      conditional_add_to_template_validation_array(header_param)
+      @header_params[header_param.get_key] = header_param.get_value
+      self
+    end
+
+    # The setter for the query parameter to be sent in the request.
+    # @param [Parameter] query_param The query parameter to be sent in the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def query_param(query_param)
+      query_param.validate
+      conditional_add_to_template_validation_array(query_param)
+      @query_params[query_param.get_key] = query_param.get_value
+      self
+    end
+
+    # The setter for the form parameter to be sent in the request.
+    # @param [Parameter] form_param The form parameter to be sent in the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def form_param(form_param)
+      form_param.validate
+      conditional_add_to_template_validation_array(form_param)
+      @form_params[form_param.get_key] = form_param.get_value
+      self
+    end
+
+    # The setter for the additional form parameter to be sent in the request.
+    # @param [Hash] additional_form_params The additional form parameter to be sent in the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def additional_form_params(additional_form_params)
+      @additional_form_params = additional_form_params
+      self
+    end
+
+    # The setter for the additional query parameter to be sent in the request.
+    # @param [Hash] additional_query_params The additional query parameter to be sent in the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def additional_query_params(additional_query_params)
+      @additional_query_params = additional_query_params
+      self
+    end
+
+    # The setter for the multipart parameter to be sent in the request.
+    # @param [Parameter] multipart_param The multipart parameter to be sent in the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def multipart_param(multipart_param)
+      multipart_param.validate
+      conditional_add_to_template_validation_array(multipart_param)
+      @multipart_params[multipart_param.get_key] = get_part(multipart_param)
+      self
+    end
+
+    # The setter for the body parameter to be sent in the request.
+    # @param [Parameter] body_param The body parameter to be sent in the request.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def body_param(body_param)
+      body_param.validate
+      conditional_add_to_template_validation_array(body_param)
+      if !body_param.get_key.nil?
+        @body_param = {} if @body_param.nil?
+        @body_param[body_param.get_key] = body_param.get_value
+      else
+        @body_param = body_param.get_value
+      end
+      self
+    end
+
+    # The setter for the callable of serializing the body.
+    # @param [Callable] body_serializer The callable for serializing the body.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def body_serializer(body_serializer)
+      @body_serializer = body_serializer
+      self
+    end
+
+    # The setter for the auth to be used for the request.
+    # @param [Authentication] auth The instance of single or multiple auths.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def auth(auth)
+      @auth = auth
+      self
+    end
+
+    # The setter for the serialization format to be used for arrays in query or form parameters of the request.
+    # @param [ArraySerializationFormat] array_serialization_format The serialization format to be used for arrays.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def array_serialization_format(array_serialization_format)
+      @array_serialization_format = array_serialization_format
+      self
+    end
+
+    # The setter for the xml attributes to used while serialization of the xml body.
+    # @param [XmlAttribute] xml_attributes The xml attribute to used while serialization of the xml body.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def xml_attributes(xml_attributes)
+      @xml_attributes = xml_attributes
+      self
+    end
+
+    # The setter for the name of the endpoint controller method to used while logging an endpoint call.
+    # @param [String] endpoint_name_for_logging The name of the endpoint controller method to used while logging.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def endpoint_name_for_logging(endpoint_name_for_logging)
+      @endpoint_name_for_logging = endpoint_name_for_logging
+      self
+    end
+
+    # The setter for the name of the endpoint controller method to used while logging an endpoint call.
+    # @param [EndpointLogger] endpoint_logger The name of the endpoint controller method to used while logging.
+    # @return [RequestBuilder] An updated instance of RequestBuilder.
+    def endpoint_logger(endpoint_logger)
+      @endpoint_logger = endpoint_logger
+      self
+    end
+
+    # Sets global configuration object for the request builder.
+    def global_configuration(global_configuration)
+      @global_configuration = global_configuration
+      self
+    end
+
+    # Add param to the template validation array, in case a template is provided.
+    def conditional_add_to_template_validation_array(parameter)
+      return if parameter.get_template.nil?
+
+      @template_validation_array.push(parameter)
+    end
+
+    # Validates the template for the params provided with a template.
+    def validate_templates
+      return if @template_validation_array.nil? || @template_validation_array.empty?
+
+      @template_validation_array.each do |parameter|
+        parameter.validate_template(@global_configuration.get_sdk_module,
+                                    @global_configuration.should_symbolize_hash)
+      end
+    end
+
+    # Builds the Http Request.
+    # @param [Hash] endpoint_context The endpoint configuration to be used while executing the request.
+    # @return [HttpRequest] An instance of HttpRequest.
+    def build(endpoint_context)
+      validate_templates
+      _url = process_url
+      _request_body = process_body
+      _request_headers = process_headers(@global_configuration)
+      _http_request = HttpRequest.new(@http_method, _url,
+                                      headers: _request_headers,
+                                      parameters: _request_body,
+                                      context: endpoint_context)
+      apply_auth(@global_configuration.get_auth_managers, _http_request)
+
+      _http_request
+    end
+
+    # Processes and resolves the endpoint URL.
+    # @return [String] The processed URL.
+    def process_url
+      @endpoint_logger.info("Preparing query URL for #{@endpoint_name_for_logging}.")
+      _base_url = @global_configuration.get_base_uri_executor.call(@server)
+      _updated_url_with_template_params = ApiHelper.append_url_with_template_parameters(@path, @template_params)
+      _url = _base_url + _updated_url_with_template_params
+      _url = get_updated_url_with_query_params(_url)
+      ApiHelper.clean_url(_url)
+    end
+
+    # Returns the URL with resolved query parameters if any.
+    # @param [String] url The URL of the endpoint.
+    # @return [String] The URL with resolved query parameters if any.
+    def get_updated_url_with_query_params(url)
+      _has_additional_query_params = (!@additional_query_params.nil? and @additional_query_params.any?)
+      _has_query_params = (!@query_params.nil? and @query_params.any?)
+      _query_params = @query_params
+      _query_params.merge!(@additional_query_params) if _has_additional_query_params
+
+      if !_query_params.nil? && _query_params.any?
+        return ApiHelper.append_url_with_query_parameters(url,
+                                                          _query_params,
+                                                          @array_serialization_format)
+      end
+
+      url
+    end
+
+    # Processes all request headers (including local, global and additional).
+    # @param [GlobalConfiguration] global_configuration The global configuration to be used while processing the URL.
+    # @return [Hash] The processed request headers to be sent in the request.
+    def process_headers(global_configuration)
+      _request_headers = {}
+      _global_headers = global_configuration.get_global_headers
+      _additional_headers = global_configuration.get_additional_headers
+
+      _has_global_headers = (!_global_headers.nil? && _global_headers.any?)
+      _has_additional_headers = (!_additional_headers.nil? && _additional_headers.any?)
+      _has_local_headers = (!@header_params.nil? and @header_params.any?)
+
+      if _has_global_headers || _has_additional_headers || _has_local_headers
+        @endpoint_logger.info("Preparing headers for #{@endpoint_name_for_logging}.")
+      end
+
+      _request_headers.merge!(_global_headers) if _has_global_headers
+      _request_headers.merge!(_additional_headers) if _has_additional_headers
+
+      if _has_local_headers
+        ApiHelper.clean_hash(@header_params)
+        _request_headers.merge!(@header_params)
+      end
+
+      _request_headers
+    end
+
+    # Processes the body parameter of the request (including form param, json body or xml body).
+    # @return [Object] The body param to be sent in the request.
+    def process_body
+      _has_form_params = (!@form_params.nil? && @form_params.any?)
+      _has_additional_form_params = (!@additional_form_params.nil? && @additional_form_params.any?)
+      _has_multipart_param = (!@multipart_params.nil? && @multipart_params.any?)
+      _has_body_param = !@body_param.nil?
+      _has_body_serializer = !@body_serializer.nil?
+      _has_xml_attributes = !@xml_attributes.nil?
+
+      if _has_form_params || _has_additional_form_params
+        @endpoint_logger.info("Preparing form parameters for #{@endpoint_name_for_logging}.")
+      elsif _has_body_param
+        @endpoint_logger.info("Preparing body parameters for #{@endpoint_name_for_logging}.")
+      end
+
+      if _has_xml_attributes
+        return process_xml_parameters
+      elsif _has_form_params || _has_additional_form_params || _has_multipart_param
+        _form_params = @form_params
+        _form_params.merge!(@form_params) if _has_form_params
+        _form_params.merge!(@multipart_params) if _has_multipart_param
+        _form_params.merge!(@additional_form_params) if _has_additional_form_params
+        # TODO: add Array serialization format support while writing the POC
+        return ApiHelper.form_encode_parameters(_form_params, @array_serialization_format)
+      elsif _has_body_param && _has_body_serializer
+        return @body_serializer.call(resolve_body_param)
+      elsif _has_body_param && !_has_body_serializer
+        return resolve_body_param
+      end
+
+      {}
+    end
+
+    # Processes the part of a multipart request and assign appropriate part value and its content-type.
+    # @param [Parameter] multipart_param The multipart parameter to be sent in the request.
+    # @return [UploadIO] The translated Faraday's UploadIO instance.
+    def get_part(multipart_param)
+      param_value = multipart_param.get_value
+      if param_value.is_a? FileWrapper
+        part = param_value.file
+        part_content_type = param_value.content_type
+      else
+        part = param_value
+        part_content_type = multipart_param.get_default_content_type
+      end
+      Faraday::UploadIO.new(part, part_content_type)
+    end
+
+    # Processes the XML body parameter.
+
+    # @return [String] The serialized xml body.
+    def process_xml_parameters
+      unless @xml_attributes.get_array_item_name.nil?
+        return @body_serializer.call(@xml_attributes.get_root_element_name,
+                                     @xml_attributes.get_array_item_name,
+                                     @xml_attributes.get_value)
+      end
+
+      @body_serializer.call(@xml_attributes.get_root_element_name, @xml_attributes.get_value)
+    end
+
+    # Resolves the body parameter to appropriate type.
+    # @return [Hash] The resolved body parameter as per the type.
+    def resolve_body_param
+      if !@body_param.nil? && @body_param.is_a?(FileWrapper)
+        @header_params['content-type'] = @body_param.content_type if !@body_param.file.nil? &&
+                                                                     !@body_param.content_type.nil?
+        @header_params['content-length'] = @body_param.file.size.to_s
+        return @body_param.file
+      elsif !@body_param.nil? && @body_param.is_a?(File)
+        @header_params['content-length'] = @body_param.size.to_s
+      end
+      @body_param
+    end
+
+    # Applies the configured auth onto the http request.
+    # @param [Hash] auth_managers The hash of auth managers.
+    # @param [HttpRequest] http_request The HTTP request on which the auth is to be applied.
+    def apply_auth(auth_managers, http_request)
+      is_valid_auth = @auth.with_auth_managers(auth_managers).valid unless @auth.nil?
+      @auth.apply(http_request) if is_valid_auth
+      raise InvalidAuthCredential, @auth.error_message if !@auth.nil? && !is_valid_auth
+    end
+  end
+end