fastpixapi 1.1.1 → 1.1.3

data/lib/fastpix_client/utils/forms.rb

@@ -23,54 +23,66 @@ module FastpixClient
       return params if obj.nil?
 
       if obj.respond_to? :fields
-        items = []
-        T.unsafe(obj).fields.each do |obj_field|
-          obj_field_name = get_field_name_lambda.call(obj_field)
-          next if obj_field_name == ''
+        _populate_form_from_object(params, field_name, explode, obj, delimiter, &get_field_name_lambda)
+      elsif obj.is_a? Hash
+        _populate_form_from_hash(params, field_name, explode, obj, delimiter)
+      elsif obj.is_a? Array
+        _populate_form_from_array(params, field_name, explode, obj, delimiter)
+      else
+        params[field_name] = val_to_string(obj)
+      end
+      params
+    end
 
-          val = obj.send(obj_field.name.to_sym)
-          next if val.nil?
+    # Populates form params from a MetadataFields object (mutates `params`).
+    def self._populate_form_from_object(params, field_name, explode, obj, delimiter, &get_field_name_lambda)
+      items = []
+      T.unsafe(obj).fields.each do |obj_field|
+        obj_field_name = get_field_name_lambda.call(obj_field)
+        next if obj_field_name == ''
 
-          if explode
-            params[obj_field_name] = [val_to_string(val)]
-          else
-            items.append("#{obj_field_name}#{delimiter}#{val_to_string(val)}")
-          end
+        val = obj.send(obj_field.name.to_sym)
+        next if val.nil?
+
+        if explode
+          params[obj_field_name] = [val_to_string(val)]
+        else
+          items.append("#{obj_field_name}#{delimiter}#{val_to_string(val)}")
         end
+      end
+      params[field_name] = [items.join(delimiter)] unless items.empty?
+    end
 
-        params[field_name] = [items.join(delimiter)] if !items.empty?
-      elsif obj.is_a? Hash
-        items = []
-        obj.each do |key, value|
-          next if value.nil?
+    # Populates form params from a Hash (mutates `params`).
+    def self._populate_form_from_hash(params, field_name, explode, obj, delimiter)
+      items = []
+      obj.each do |key, value|
+        next if value.nil?
 
-          if explode
-            params[key] = val_to_string(value)
-          else
-            items.append("#{key}#{delimiter}#{val_to_string(value)}")
-          end
+        if explode
+          params[key] = val_to_string(value)
+        else
+          items.append("#{key}#{delimiter}#{val_to_string(value)}")
         end
-        params[field_name] = [items.join(delimiter)] if !items.empty?
+      end
+      params[field_name] = [items.join(delimiter)] unless items.empty?
+    end
 
-      elsif obj.is_a? Array
-        items = []
-        obj.each do |value|
-          next if value.nil?
+    # Populates form params from an Array (mutates `params`).
+    def self._populate_form_from_array(params, field_name, explode, obj, delimiter)
+      items = []
+      obj.each do |value|
+        next if value.nil?
 
-          if explode
-            params[field_name] = [] if !params.key? field_name
+        if explode
+          params[field_name] = [] unless params.key? field_name
 
-            params[field_name].append(val_to_string(value))
-          else
-            items.append(val_to_string(value))
-          end
+          params[field_name].append(val_to_string(value))
+        else
+          items.append(val_to_string(value))
         end
-        params[field_name] = items.map(&:to_s).join(delimiter) if !items.empty?
-
-      else
-        params[field_name] = val_to_string(obj)
       end
-      params
+      params[field_name] = items.map(&:to_s).join(delimiter) unless items.empty?
     end
 
     sig { params(media_type: String, request: Object).returns([String, Object, T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]]]) }
@@ -83,73 +95,57 @@ module FastpixClient
         field_metadata = field.metadata[:multipart_form]
         next if field_metadata.nil?
 
-        if field_metadata[:file] == true
-          field_name = field_metadata[:field_name]
-          
-          # Handle arrays of files
-          if val.is_a? Array
-            val.each do |file_obj|
-              file_name = T.let('', String)
-              content = nil
-
-              T.must(file_obj).fields.each do |file_field|
-                file_metadata = file_field.metadata[:multipart_form]
-                next if file_metadata.nil?
-
-                if file_metadata[:content] == true
-                  content = T.let(file_obj.send(file_field.name), String)
-                else
-                  file_name = T.let(file_obj.send(file_field.name), String)
-                end
-              end
-              raise StandardError, 'invalid multipart/form-data file' if T.unsafe(file_name) == '' || T.unsafe(content).nil?
-
-              form.append([field_name, [file_name, content]])
-            end
-          else
-            # Handle single file
-            file_name = T.let('', String)
-            content = nil
-
-            T.must(val).fields.each do |file_field|
-              file_metadata = file_field.metadata[:multipart_form]
-              next if file_metadata.nil?
-
-              if file_metadata[:content] == true
-                content = T.let(val.send(file_field.name), String)
-              else
-                file_name = T.let(val.send(file_field.name), String)
-              end
-            end
-            raise StandardError, 'invalid multipart/form-data file' if T.unsafe(file_name) == '' || T.unsafe(content).nil?
+        _append_multipart_field(form, field, field_metadata, val)
+      end
+      [media_type, nil, form]
+    end
 
-            form.append([field_name, [file_name, content]])
-          end
-        elsif field_metadata[:json] == true
-          to_append = [
-            field_metadata.fetch(:field_name, field.name), [
-              nil, ::Crystalline.to_json(val), 'application/json'
-            ]
-          ]
-          form.append(to_append)
+    # Extracts [file_name, content] from a multipart file object, raising if invalid.
+    def self._extract_multipart_file(file_obj)
+      file_name = T.let('', String)
+      content = nil
+
+      T.must(file_obj).fields.each do |file_field|
+        file_metadata = file_field.metadata[:multipart_form]
+        next if file_metadata.nil?
+
+        if file_metadata[:content] == true
+          content = T.let(file_obj.send(file_field.name), String)
         else
-          field_name = field_metadata.fetch(
-            :field_name, field.name
-          )
-          if val.is_a? Array
-            val.each do |value|
-              next if value.nil?
-
-              form.append(
-                [field_name, [nil, val_to_string(value)]]
-              )
-            end
-          else
-            form.append([field_name, [nil, val_to_string(val)]])
+          file_name = T.let(file_obj.send(file_field.name), String)
+        end
+      end
+      raise ArgumentError, 'invalid multipart/form-data file' if T.unsafe(file_name) == '' || T.unsafe(content).nil?
+
+      [file_name, content]
+    end
+
+    # Appends a single request field to the multipart form (mutates `form`).
+    def self._append_multipart_field(form, field, field_metadata, val)
+      if field_metadata[:file] == true
+        field_name = field_metadata[:field_name]
+        # Handle arrays of files and single files alike
+        if val.is_a? Array
+          val.each { |file_obj| form.append([field_name, _extract_multipart_file(file_obj)]) }
+        else
+          form.append([field_name, _extract_multipart_file(val)])
+        end
+      elsif field_metadata[:json] == true
+        form.append(
+          [field_metadata.fetch(:field_name, field.name), [nil, ::Crystalline.to_json(val), 'application/json']]
+        )
+      else
+        field_name = field_metadata.fetch(:field_name, field.name)
+        if val.is_a? Array
+          val.each do |value|
+            next if value.nil?
+
+            form.append([field_name, [nil, val_to_string(value)]])
           end
+        else
+          form.append([field_name, [nil, val_to_string(val)]])
         end
       end
-      [media_type, nil, form]
     end
 
 
@@ -188,7 +184,7 @@ module FastpixClient
                 )
               )
             else
-              raise StandardError, "Invalid form style for field #{field.name}"
+              raise ArgumentError, "Invalid form style for field #{field.name}"
             end
           end
         end
@@ -197,7 +193,7 @@ module FastpixClient
           form[key] = [val_to_string(value)]
         end
       else
-        raise StandardError, "Invalid request body type #{data.class}"
+        raise ArgumentError, "Invalid request body type #{data.class}"
       end
 
       form

data/lib/fastpix_client/utils/headers.rb

@@ -33,45 +33,55 @@ module FastpixClient
       return '' if obj.nil?
 
       if obj.respond_to? :fields
-        items = []
-        T.unsafe(obj).fields.each do |obj_field|
-          obj_param_metadata = obj_field.metadata[:header]
-          next if obj_param_metadata.nil?
-
-          obj_field_name = obj_param_metadata.fetch(:field_name, obj_field.name)
-          next if obj_field_name == ''
-
-          val = obj.send(obj_field.name)
-          next if val.nil?
-
-          if explode
-            items.append("#{obj_field_name}=#{val_to_string(val)}")
-          else
-            items.append(obj_field_name)
-            items.append(val_to_string(val))
-          end
-        end
-
-        items.join(',') if !items.empty?
+        _serialize_header_from_object(explode, obj)
       elsif obj.is_a? Hash
-        items = []
-        obj.each do |key, value|
-          next if value.nil?
-
-          if explode
-            items.append("#{key}=#{val_to_string(value)}")
-          else
-            items.append(key)
-            items.append(val_to_string(value))
-          end
-        end
-
-        items.join(',') if !items.empty?
+        _serialize_header_from_hash(explode, obj)
       elsif obj.is_a? Array
-        items = obj.filter { |v| !v.nil? }.map { |v| val_to_string(v) }.join(',')
+        obj.filter { |v| !v.nil? }.map { |v| val_to_string(v) }.join(',')
       else
         val_to_string(obj)
       end
     end
+
+    # Serializes a MetadataFields object into a header string (nil when empty).
+    def self._serialize_header_from_object(explode, obj)
+      items = []
+      T.unsafe(obj).fields.each do |obj_field|
+        obj_param_metadata = obj_field.metadata[:header]
+        next if obj_param_metadata.nil?
+
+        obj_field_name = obj_param_metadata.fetch(:field_name, obj_field.name)
+        next if obj_field_name == ''
+
+        val = obj.send(obj_field.name)
+        next if val.nil?
+
+        if explode
+          items.append("#{obj_field_name}=#{val_to_string(val)}")
+        else
+          items.append(obj_field_name)
+          items.append(val_to_string(val))
+        end
+      end
+
+      items.join(',') unless items.empty?
+    end
+
+    # Serializes a Hash into a header string (nil when empty).
+    def self._serialize_header_from_hash(explode, obj)
+      items = []
+      obj.each do |key, value|
+        next if value.nil?
+
+        if explode
+          items.append("#{key}=#{val_to_string(value)}")
+        else
+          items.append(key)
+          items.append(val_to_string(value))
+        end
+      end
+
+      items.join(',') unless items.empty?
+    end
   end
 end

data/lib/fastpix_client/utils/query_params.rb

@@ -14,7 +14,7 @@ module FastpixClient
     sig { params(clazz: Object, query_params: Object, url_override: T.nilable(::String), gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[T.any(String, Symbol), T::Array[String]]) }
     def self.get_query_params(clazz, query_params, url_override = nil, gbls = nil)
       parsed_params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
-      if !url_override.nil?
+      unless url_override.nil?
         parsed_url = URI.parse url_override
         URI.decode_www_form(parsed_url.query.to_s).each do |key, value|
           parsed_params[key] ||= []
@@ -55,7 +55,7 @@ module FastpixClient
               metadata, f_name, value, '|'
             )
           else
-            raise StandardError, 'not yet implemented'
+            raise ArgumentError, 'not yet implemented'
           end
         end
       end
@@ -72,45 +72,55 @@ module FastpixClient
       return params if obj.nil?
 
       if obj.respond_to? :fields
-        T.unsafe(obj).fields.each do |obj_field|
-          obj_param_metadata = obj_field.metadata[:query_param]
-          next if obj_param_metadata.nil?
+        _deep_object_from_object(params, metadata, field_name, obj)
+      elsif obj.is_a? Hash
+        _deep_object_from_hash(params, metadata, field_name, obj)
+      end
+      params
+    end
 
-          val = obj.send(obj_field.name)
-          next if val.nil?
+    # Adds deepObject query params from a MetadataFields object (mutates `params`).
+    def self._deep_object_from_object(params, metadata, field_name, obj)
+      T.unsafe(obj).fields.each do |obj_field|
+        obj_param_metadata = obj_field.metadata[:query_param]
+        next if obj_param_metadata.nil?
 
-          key = "#{metadata.fetch(:field_name, field_name)}[#{obj_param_metadata.fetch(:field_name, obj_field.name)}]"
-          if val.is_a? Array
-            val.each do |v|
-              next if v.nil?
+        val = obj.send(obj_field.name)
+        next if val.nil?
 
-              params[key] = [] if !params.include? key
+        key = "#{metadata.fetch(:field_name, field_name)}[#{obj_param_metadata.fetch(:field_name, obj_field.name)}]"
+        if val.is_a? Array
+          val.each do |v|
+            next if v.nil?
 
-              T.must(params[key]) << val_to_string(v)
-            end
-          else
-            params[key] = [val_to_string(val)]
+            params[key] = [] unless params.include? key
+
+            T.must(params[key]) << val_to_string(v)
           end
+        else
+          params[key] = [val_to_string(val)]
         end
-      elsif obj.is_a? Hash
-        obj.each do |key, value|
-          next if value.nil?
+      end
+    end
 
-          param_key = "#{metadata.fetch(:field_name, field_name)}[#{key}]"
-          if value.is_a? Array
-            value.each do |val|
-              next if val.nil?
+    # Adds deepObject query params from a Hash (mutates `params`).
+    def self._deep_object_from_hash(params, metadata, field_name, obj)
+      obj.each do |key, value|
+        next if value.nil?
 
-              params[param_key] = [] if !params.include? param_key
+        param_key = "#{metadata.fetch(:field_name, field_name)}[#{key}]"
+        if value.is_a? Array
+          value.each do |val|
+            next if val.nil?
 
-              T.must(params[param_key]).append(val_to_string(val))
-            end
-          else
-            params[param_key] = [val_to_string(value)]
+            params[param_key] = [] unless params.include? param_key
+
+            T.must(params[param_key]).append(val_to_string(val))
           end
+        else
+          params[param_key] = [val_to_string(value)]
         end
       end
-      params
     end
 
 

data/lib/fastpix_client/utils/request_bodies.rb

@@ -32,13 +32,9 @@ module FastpixClient
       request_val = request.send(request_field_name)
 
       request_metadata = T.let(nil, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]]))
-      T.unsafe(request).fields.each do |f|
-        if f.name == request_field_name
-          request_metadata = f.metadata[:request]
-          break
-        end
-      end
-      raise StandardError, 'invalid request type' if request_metadata.nil?
+      matched_field = T.unsafe(request).fields.find { |f| f.name == request_field_name }
+      request_metadata = matched_field.metadata[:request] unless matched_field.nil?
+      raise ArgumentError, 'invalid request type' if request_metadata.nil?
 
       serialize_content_type(
         request_metadata.fetch(:media_type, 'application/octet-stream'), request_val
@@ -55,7 +51,7 @@ module FastpixClient
       return media_type, serialize_form_data(request), nil if media_type.match('^application\/x-www-form-urlencoded.*')
       return media_type, request, nil if request.is_a?(String) || request.is_a?(Array)
 
-      raise StandardError, "invalid request body type #{request.class} for mediaType #{media_type}"
+      raise ArgumentError, "invalid request body type #{request.class} for mediaType #{media_type}"
     end
   end
 end

data/lib/fastpix_client/utils/security.rb

@@ -12,6 +12,9 @@ module FastpixClient
   module Utils
     extend T::Sig
 
+    SECURITY_NOT_SUPPORTED = 'not supported'
+    BEARER_PREFIX = 'bearer '
+
     sig { params(req: Faraday::Request, security: Object).void }
     def self.configure_request_security(req, security)
       return if security.nil?
@@ -75,33 +78,42 @@ module FastpixClient
     def self._parse_security_scheme_value(req, scheme_metadata, security_metadata, value)
       scheme_type = scheme_metadata[:type]
       sub_type = scheme_metadata[:sub_type]
-
       header_name = security_metadata[:field_name]
 
       case scheme_type
       when 'apiKey'
-        case sub_type
-        when 'header'
-          req.headers[header_name] = value
-        when 'query'
-          req.params[header_name] = value
-        when 'cookie'
-          req.headers['Cookie'][header_name] = value
-        else
-          raise StandardError, 'not supported'
-        end
-      when 'openIdConnect'
-        req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
-      when 'oauth2'
-        req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
+        _apply_api_key_scheme(req, sub_type, header_name, value)
+      when 'openIdConnect', 'oauth2'
+        req.headers[header_name] = _bearerize(value)
       when 'http'
         if sub_type == 'bearer'
-          req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
+          req.headers[header_name] = _bearerize(value)
         elsif sub_type != 'custom'
-          raise StandardError, 'not supported'
+          raise ArgumentError, SECURITY_NOT_SUPPORTED
         end
       else
-        raise StandardError, 'not supported'
+        raise ArgumentError, SECURITY_NOT_SUPPORTED
+      end
+    end
+
+    # Prefixes the value with `Bearer ` unless it is already a bearer token.
+    sig { params(value: String).returns(String) }
+    def self._bearerize(value)
+      value.downcase.start_with?(BEARER_PREFIX) ? value : "Bearer #{value}"
+    end
+
+    # Applies an apiKey security scheme to the request for the given sub_type.
+    sig { params(req: Faraday::Request, sub_type: T.nilable(String), header_name: T.nilable(String), value: String).void }
+    def self._apply_api_key_scheme(req, sub_type, header_name, value)
+      case sub_type
+      when 'header'
+        req.headers[header_name] = value
+      when 'query'
+        req.params[header_name] = value
+      when 'cookie'
+        req.headers['Cookie'][header_name] = value
+      else
+        raise ArgumentError, SECURITY_NOT_SUPPORTED
       end
     end
 

data/lib/fastpix_client/utils/url.rb

@@ -21,65 +21,93 @@ module FastpixClient
 
         f_name = param_metadata.fetch(:field_name, f.name)
         serialization = param_metadata.fetch(:serialization, '')
-        if serialization != ''
-          serialized_params = _get_serialized_params(param_metadata, f_name, param)
-          serialized_params.each do |k, v|
-            path = path.sub("{#{k}}", v.join(', '))
-          end
+        path = _substitute_path_param(path, param_metadata, f, f_name, serialization, param)
+      end
+
+      server_url.delete_suffix('/') + path
+    end
+
+    # Substitutes a single path param into the path, returning the updated path.
+    def self._substitute_path_param(path, param_metadata, f, f_name, serialization, param)
+      if serialization != ''
+        serialized_params = _get_serialized_params(param_metadata, f_name, param)
+        serialized_params.each do |k, v|
+          path = path.sub("{#{k}}", v.join(', '))
+        end
+        return path
+      end
+
+      placeholder = "{#{param_metadata.fetch(:field_name, f.name)}}"
+      if param.is_a? Array
+        path.sub(placeholder, _path_param_from_array(param))
+      elsif param.is_a? Hash
+        path.sub(placeholder, _path_param_from_hash(param_metadata, param))
+      elsif param.class.include?(::Crystalline::MetadataFields)
+        path.sub(placeholder, _path_param_from_object(param_metadata, f, param))
+      else
+        path.sub(placeholder, _path_param_scalar(param))
+      end
+    end
+
+    def self._path_param_from_array(param)
+      pp_vals = []
+      param.each do |pp_val|
+        pp_vals.append(pp_val.to_s)
+      end
+      pp_vals.join(',')
+    end
+
+    def self._path_param_from_hash(param_metadata, param)
+      pp_vals = []
+      param.each do |pp_key, pp_val|
+        value = val_to_string(pp_val)
+
+        if param_metadata.fetch(:explode, false)
+          pp_vals.append("#{pp_key}=#{value}")
         else
-          if param.is_a? Array
-            pp_vals = []
-            param.each do |pp_val|
-              pp_vals.append(pp_val.to_s)
-            end
-            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
-          elsif param.is_a? Hash
-            pp_vals = []
-            param.each do |pp_key, pp_val|
-              value = val_to_string(pp_val)
-
-              if param_metadata.fetch(:explode, false)
-                pp_vals.append("#{pp_key}=#{value}")
-              else
-                pp_vals.append("#{pp_key},#{value}")
-              end
-            end
-            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
-          elsif param.class.include?(::Crystalline::MetadataFields)
-            pp_vals = []
-            attrs = T.unsafe(param).fields.filter { |field| field.name && param.respond_to?(field.name.to_sym) }.map(&:name)
-            attrs.each do |attr|
-              field = T.unsafe(param).field(attr)
-
-              param_value_metadata = field.metadata[:path_param]
-
-              next if param_value_metadata.nil?
-
-              parm_name = param_value_metadata.fetch(:field_name, f.name)
-
-              param_field_val = param.send(attr)
-
-              if param_field_val.class.respond_to?(:enums)
-                param_field_val = param_field_val.serialize
-              elsif param_field_val.is_a? DateTime
-                param_field_val = param_field_val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
-              end
-              if !field.nil? && ::Crystalline::Utils.nilable?(field.type) && param_field_val.nil?
-                next
-              elsif param_metadata.fetch(:explode, false)
-                pp_vals.append("#{parm_name}=#{param_field_val}")
-              else
-                pp_vals.append("#{parm_name},#{param_field_val}")
-              end
-            end
-            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
-          else
-            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", param.to_s)
-          end
+          pp_vals.append("#{pp_key},#{value}")
         end
       end
+      pp_vals.join(',')
+    end
 
-      server_url.delete_suffix('/') + path
+    def self._path_param_from_object(param_metadata, f, param)
+      pp_vals = []
+      attrs = T.unsafe(param).fields.filter { |field| field.name && param.respond_to?(field.name.to_sym) }.map(&:name)
+      attrs.each do |attr|
+        field = T.unsafe(param).field(attr)
+
+        param_value_metadata = field.metadata[:path_param]
+
+        next if param_value_metadata.nil?
+
+        parm_name = param_value_metadata.fetch(:field_name, f.name)
+
+        param_field_val = param.send(attr)
+
+        if param_field_val.class.respond_to?(:enums)
+          param_field_val = param_field_val.serialize
+        elsif param_field_val.is_a? DateTime
+          param_field_val = param_field_val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+        end
+        if !field.nil? && ::Crystalline::Utils.nilable?(field.type) && param_field_val.nil?
+          next
+        elsif param_metadata.fetch(:explode, false)
+          pp_vals.append("#{parm_name}=#{param_field_val}")
+        else
+          pp_vals.append("#{parm_name},#{param_field_val}")
+        end
+      end
+      pp_vals.join(',')
+    end
+
+    def self._path_param_scalar(param)
+      if param.class.respond_to?(:enums)
+        param = T.cast(param, T::Enum).serialize
+      elsif param.is_a? DateTime
+        param = param.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+      end
+      param.to_s
     end
 
     sig { params(url_with_params: String, params: T::Hash[Symbol, T.any(String, T::Enum)]).returns(String) }