nylas 6.6.0 → 6.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b88e46de5b92ca56b82971334bc996b373407c76612b7ae7cf560a6496c5fb57
-  data.tar.gz: 25caea97521efd4fd2f903eed63b375b91a47142c797fd109cb60169a4d51920
+  metadata.gz: fa916629fd9482f57599bd8cb7887f69575cc12cffd4f2d3d0fa37c5cd163b70
+  data.tar.gz: 906042891eb1519df1ff287ae27104b5f871edcbb938e25cc23e65a1d71452a0
 SHA512:
-  metadata.gz: 4af7e805753ad3df593249379933f58cfc42b25c962fafbfae041554d87fe66d59dd4ee1b18475bcf0c69e65dcfe57f1a384d9e9289e9c74fbda20b92d568fb6
-  data.tar.gz: 704f122a8273212641bcb02c4b1dd6b225d00f64f23655cd3c35ec81d654e1c1e6585d44a99a7caf7a991f4ee8f3fc6f05c61008cc1496b4c2f5fc5521ee9c28
+  metadata.gz: 1f7203ab924ec04f7efda91875003a8ffa10a182800ae7f0ffa8fb1cb7ad01a5cb4403bf99d79d84e58514acd25b45e8446a5522f771b7bd110e1c17595d94c1
+  data.tar.gz: fb23ac5760b2ed22f253dba8316baf5542ca29f654b1ca5b92345d34918e138065051b207435a62c82d41cefdbb7d3f6ecec0df0eee8294c3471518cc54f3151

data/lib/nylas/handler/http_client.rb

@@ -2,6 +2,7 @@
 
 require "httparty"
 require "net/http"
+require "net/http/post/multipart"
 
 require_relative "../errors"
 require_relative "../version"
@@ -41,7 +42,8 @@ module Nylas
             content_type = response.headers["content-type"].downcase
           end
 
-          parsed_response = parse_json_evaluate_error(result.code.to_i, response.body, path, content_type)
+          parsed_response = parse_json_evaluate_error(result.code.to_i, response.body, path, content_type,
+                                                      response.headers)
           # Include headers in the response
           parsed_response[:headers] = response.headers unless parsed_response.nil?
           parsed_response
@@ -134,7 +136,9 @@ module Nylas
 
     private
 
-    # Sends a request to the Nylas REST API using HTTParty.
+    # Sends a request to the Nylas REST API using HTTParty or Net::HTTP for multipart.
+    # Multipart requests use Net::HTTP::Post::Multipart (multipart-post gem) because
+    # HTTParty's multipart handling produces malformed requests that the Nylas API rejects.
     #
     # @param method [Symbol] HTTP method for the API call. Either :get, :post, :delete, or :patch.
     # @param url [String] URL for the API call.
@@ -142,25 +146,16 @@ module Nylas
     # @param payload [String, Hash] Body to send with the request.
     # @param timeout [Hash] Timeout value to send with the request.
     def httparty_execute(method:, url:, headers:, payload:, timeout:)
-      options = {
-        headers: headers,
-        timeout: timeout
-      }
-
-      # Handle multipart uploads
-      if payload.is_a?(Hash) && file_upload?(payload)
-        options[:multipart] = true
-        options[:body] = prepare_multipart_payload(payload)
-      elsif payload
-        options[:body] = payload
+      if method == :post && payload.is_a?(Hash) && file_upload?(payload)
+        response = execute_multipart_request(url: url, headers: headers, payload: payload, timeout: timeout)
+      else
+        options = { headers: headers, timeout: timeout }
+        options[:body] = payload if payload
+        response = HTTParty.send(method, url, options)
       end
 
-      response = HTTParty.send(method, url, options)
-
-      # Create a compatible response object that mimics RestClient::Response
       result = create_response_wrapper(response)
 
-      # Call the block with the response in the same format as rest-client
       if block_given?
         yield response, nil, result
       else
@@ -168,6 +163,77 @@ module Nylas
       end
     end
 
+    # Executes multipart POST using Net::HTTP::Post::Multipart (fixes issue #538).
+    # HTTParty's multipart produces malformed requests; multipart-post/UploadIO works correctly.
+    def execute_multipart_request(url:, headers:, payload:, timeout:)
+      uri = URI.parse(url)
+      params = build_multipart_params(payload)
+
+      req = Net::HTTP::Post::Multipart.new(uri.path, params)
+      headers.each { |key, value| req[key] = value }
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.read_timeout = timeout
+      http.open_timeout = timeout
+
+      response = http.request(req)
+
+      create_httparty_like_response(response)
+    end
+
+    # Build params hash for Net::HTTP::Post::Multipart with UploadIO for file fields.
+    def build_multipart_params(payload)
+      params = {}
+      payload.each do |key, value|
+        params[key] = if key.is_a?(String) && key != "message" && file_like_value?(value)
+                        value_to_upload_io(value)
+                      else
+                        value.to_s
+                      end
+      end
+      params
+    end
+
+    def file_like_value?(value)
+      return true if value.respond_to?(:read) && (value.is_a?(File) ? !value.closed? : true)
+      if value.is_a?(String) && (value.respond_to?(:original_filename) || value.respond_to?(:content_type))
+        return true
+      end
+
+      false
+    end
+
+    # Convert File, String, or StringIO to UploadIO for multipart-post.
+    def value_to_upload_io(value)
+      content_type = value.respond_to?(:content_type) ? value.content_type : "application/octet-stream"
+      filename = value.respond_to?(:original_filename) ? value.original_filename : "file.bin"
+
+      io = if value.respond_to?(:read) && value.respond_to?(:rewind)
+             value.rewind if value.respond_to?(:rewind)
+             value
+           else
+             require "stringio"
+             content = value.to_s
+             content = content.dup.force_encoding(Encoding::ASCII_8BIT) if content.is_a?(String)
+             StringIO.new(content)
+           end
+
+      UploadIO.new(io, content_type, filename)
+    end
+
+    # Create response object compatible with HTTParty::Response interface.
+    def create_httparty_like_response(net_http_response)
+      headers = net_http_response.to_hash
+      headers = headers.transform_values { |v| v.is_a?(Array) && v.one? ? v.first : v }
+
+      OpenStruct.new(
+        body: net_http_response.body,
+        code: net_http_response.code.to_i,
+        headers: headers
+      )
+    end
+
     # Create a response wrapper that mimics RestClient::Response.code behavior
     def create_response_wrapper(response)
       OpenStruct.new(code: response.code)
@@ -187,10 +253,20 @@ module Nylas
       # Check if payload was prepared by FileUtils.build_form_request for multipart uploads
       # This handles binary content attachments that are strings with added singleton methods
       has_message_field = payload.key?("message") && payload["message"].is_a?(String)
-      has_attachment_fields = payload.keys.any? { |key| key.is_a?(String) && key.match?(/^file\d+$/) }
 
-      # If we have both a "message" field and "file{N}" fields, this indicates
-      # the payload was prepared by FileUtils.build_form_request for multipart upload
+      # Check for attachment fields - these can have custom content_id values (not just "file{N}")
+      # FileUtils.build_form_request creates entries with string values that have singleton methods
+      # like original_filename and content_type defined on them
+      has_attachment_fields = payload.any? do |key, value|
+        next false unless key.is_a?(String) && key != "message"
+
+        # Check if the value is a string with attachment-like singleton methods
+        # (original_filename or content_type), which indicates it's a file content
+        value.is_a?(String) && (value.respond_to?(:original_filename) || value.respond_to?(:content_type))
+      end
+
+      # If we have both a "message" field and attachment fields with file metadata,
+      # this indicates the payload was prepared by FileUtils.build_form_request
       has_message_field && has_attachment_fields
     end
 
@@ -311,37 +387,34 @@ module Nylas
     end
 
     # Parses the response from the Nylas API and evaluates for errors.
-    def parse_json_evaluate_error(http_code, response, path, content_type = nil)
+    def parse_json_evaluate_error(http_code, response, path, content_type = nil, headers = nil)
       begin
         response = parse_response(response) if content_type == "application/json"
       rescue Nylas::JsonParseError
-        handle_failed_response(http_code, response, path)
+        handle_failed_response(http_code, response, path, headers)
         raise
       end
 
-      handle_failed_response(http_code, response, path)
+      handle_failed_response(http_code, response, path, headers)
       response
     end
 
     # Handles failed responses from the Nylas API.
-    def handle_failed_response(http_code, response, path)
+    def handle_failed_response(http_code, response, path, headers = nil)
       return if HTTP_SUCCESS_CODES.include?(http_code)
 
       case response
       when Hash
-        raise error_hash_to_exception(response, http_code, path)
+        raise error_hash_to_exception(response, http_code, path, headers)
       else
         raise NylasApiError.parse_error_response(response, http_code)
       end
     end
 
     # Converts error hashes to exceptions.
-    def error_hash_to_exception(response, status_code, path)
+    def error_hash_to_exception(response, status_code, path, headers = nil)
       return if !response || !response.key?(:error)
 
-      # Safely get headers without risking KeyError
-      headers = response.key?(:headers) ? response[:headers] : nil
-
       if %W[#{api_uri}/v3/connect/token #{api_uri}/v3/connect/revoke].include?(path)
         NylasOAuthError.new(response[:error], response[:error_description], response[:error_uri],
                             response[:error_code], status_code)

data/lib/nylas/resources/webhooks.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "cgi"
 require_relative "resource"
 require_relative "../handler/api_operations"
 
@@ -115,14 +114,14 @@ module Nylas
     # @return [String] The challenge parameter
     def self.extract_challenge_parameter(url)
       url_object = URI.parse(url)
-      query = CGI.parse(url_object.query || "")
+      params = URI.decode_www_form(url_object.query || "")
+      challenge_pair = params.find { |k, _| k == "challenge" }
 
-      challenge_parameter = query["challenge"]
-      if challenge_parameter.nil? || challenge_parameter.empty? || challenge_parameter.first.nil?
+      if challenge_pair.nil? || challenge_pair.last.to_s.empty?
         raise "Invalid URL or no challenge parameter found."
       end
 
-      challenge_parameter.first
+      challenge_pair.last
     end
   end
 end

data/lib/nylas/utils/file_utils.rb

@@ -28,12 +28,13 @@ module Nylas
 
       attachments.each_with_index do |attachment, index|
         file = attachment[:content] || attachment["content"]
+        file_path = attachment[:file_path] || attachment["file_path"]
         if file.respond_to?(:closed?) && file.closed?
-          unless attachment[:file_path]
+          unless file_path
             raise ArgumentError, "The file at index #{index} is closed and no file_path was provided."
           end
 
-          file = File.open(attachment[:file_path], "rb")
+          file = File.open(file_path, "rb")
         end
 
         # Setting original filename and content type if available. See rest-client#lib/restclient/payload.rb
@@ -87,7 +88,9 @@ module Nylas
 
       # Use form data only if the attachment size is greater than 3mb
       attachments = payload[:attachments]
-      attachment_size = attachments&.sum { |attachment| attachment[:size] || 0 } || 0
+      # Support both string and symbol keys for attachment size to handle
+      # user-provided hashes that may use either key type
+      attachment_size = attachments&.sum { |attachment| attachment[:size] || attachment["size"] || 0 } || 0
 
       # Handle the attachment encoding depending on the size
       if attachment_size >= FORM_DATA_ATTACHMENT_SIZE

data/lib/nylas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nylas
-  VERSION = "6.6.0"
+  VERSION = "6.7.1"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nylas
 version: !ruby/object:Gem::Version
-  version: 6.6.0
+  version: 6.7.1
 platform: ruby
 authors:
 - Nylas, Inc.
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -58,6 +57,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.5.1
+- !ruby/object:Gem::Dependency
+  name: multipart-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: ostruct
   requirement: !ruby/object:Gem::Requirement
@@ -140,14 +153,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.22'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.22'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: rubocop-capybara
   requirement: !ruby/object:Gem::Requirement
@@ -295,7 +308,6 @@ files:
 - lib/nylas/resources/webhooks.rb
 - lib/nylas/utils/file_utils.rb
 - lib/nylas/version.rb
-homepage:
 licenses:
 - MIT
 metadata:
@@ -305,7 +317,6 @@ metadata:
   homepage_uri: https://www.nylas.com
   source_code_uri: https://github.com/nylas/nylas-ruby
   github_repo: https://github.com/nylas/nylas-ruby
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -320,8 +331,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Gem for interacting with the Nylas API
 test_files: []