nylas 6.5.0 → 6.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9529fffa30430e822edf113d38aa1a179f0995b29d2bec8c3ac5f9a26d4d8c7
-  data.tar.gz: 8710b98962a46bef277461df24f5e64dedd9bdbe7949838b2b3d8aab38b36f10
+  metadata.gz: cc90a16ef74fc2f47d6f35ada72d9cd80e3e842e08d9d5b1916a819ae36c0808
+  data.tar.gz: b2c8494899f1b2ff4620dfbcce0aeb52e037adfe97f1609bcaaf455bfb843745
 SHA512:
-  metadata.gz: 20e35b192df7f3dfaf0d50065556d3ef0c19e959504dc124ec3bd2a6f657ffebb7a61b4808517494b2d79d4ceccdd8ce88e45d49109c142ad366592481a67b56
-  data.tar.gz: d957251f63c3c8aa8b90adde51ba2ea7fe52be3b08ca8017e1b91a22c4e42c4d428a720c1b3a18191d1861d2bf379ebd93e481b30547ffbe4ce8f99578e85fb1
+  metadata.gz: c9cda94765c3957d6457071ac616dd12a3a807378773b566da0be82b39c5a89db370049f21744b91ed8f3a5abf211b6c75363f8df10f52d102007becfcd2a635
+  data.tar.gz: e50d00d31fdb2ae23058d146b38cc75a5a75f239ba19220b5c28280defe4624b4ab4d858ec3abd496555ab6b0f35033ac2c606ed2bc346572f0593df0cebb5cc

data/lib/nylas/handler/http_client.rb

@@ -41,7 +41,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
@@ -103,6 +104,7 @@ module Nylas
       is_multipart = !payload.nil? && (payload["multipart"] || payload[:multipart])
 
       if !payload.nil? && !is_multipart
+        normalize_json_encodings!(payload)
         payload = payload&.to_json
         resulting_headers["Content-type"] = "application/json"
       elsif is_multipart
@@ -149,7 +151,7 @@ module Nylas
       # Handle multipart uploads
       if payload.is_a?(Hash) && file_upload?(payload)
         options[:multipart] = true
-        options[:body] = payload
+        options[:body] = prepare_multipart_payload(payload)
       elsif payload
         options[:body] = payload
       end
@@ -176,9 +178,113 @@ module Nylas
     def file_upload?(payload)
       return false unless payload.is_a?(Hash)
 
-      payload.values.any? do |value|
+      # Check for traditional file uploads (File objects or objects that respond to :read)
+      has_file_objects = payload.values.any? do |value|
         value.respond_to?(:read) || (value.is_a?(File) && !value.closed?)
       end
+
+      return true if has_file_objects
+
+      # 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
+      has_message_field && has_attachment_fields
+    end
+
+    # Prepare multipart payload for HTTParty compatibility
+    # HTTParty requires all multipart fields to have compatible encodings
+    def prepare_multipart_payload(payload)
+      require "stringio"
+
+      modified_payload = payload.dup
+
+      # First, normalize all string encodings to prevent HTTParty encoding conflicts
+      normalize_multipart_encodings!(modified_payload)
+
+      # Handle binary content attachments (file0, file1, etc.) by converting them to enhanced StringIO
+      # HTTParty expects file uploads to be objects with full file-like interface
+      modified_payload.each do |key, value|
+        next unless key.is_a?(String) && key.match?(/^file\d+$/) && value.is_a?(String)
+
+        # Get the original value to check for singleton methods
+        original_value = payload[key]
+
+        # Create an enhanced StringIO object for HTTParty compatibility
+        string_io = create_file_like_stringio(value)
+
+        # Preserve filename and content_type if they exist as singleton methods
+        if original_value.respond_to?(:original_filename)
+          string_io.define_singleton_method(:original_filename) { original_value.original_filename }
+        end
+
+        if original_value.respond_to?(:content_type)
+          string_io.define_singleton_method(:content_type) { original_value.content_type }
+        end
+
+        modified_payload[key] = string_io
+      end
+
+      modified_payload
+    end
+
+    # Normalize string encodings in multipart payload to prevent HTTParty encoding conflicts
+    # This ensures all string fields use consistent ASCII-8BIT encoding for multipart compatibility
+    def normalize_multipart_encodings!(payload)
+      payload.each do |key, value|
+        next unless value.is_a?(String)
+
+        # Force all string values to ASCII-8BIT encoding for multipart compatibility
+        # HTTParty/multipart-post expects binary encoding for consistent concatenation
+        payload[key] = value.dup.force_encoding(Encoding::ASCII_8BIT)
+      end
+    end
+
+    # Normalize JSON encodings for attachment content to ensure binary data is base64 encoded.
+    # This handles cases where users pass raw binary content directly instead of file objects.
+    def normalize_json_encodings!(payload)
+      return unless payload.is_a?(Hash)
+
+      # Handle attachment content encoding for JSON serialization
+      attachments = payload[:attachments] || payload["attachments"]
+      return unless attachments
+
+      attachments.each do |attachment|
+        content = attachment[:content] || attachment["content"]
+        next unless content.is_a?(String)
+
+        # If content appears to be binary (non-UTF-8), base64 encode it
+        next unless content.encoding == Encoding::ASCII_8BIT || !content.valid_encoding?
+
+        encoded_content = Base64.strict_encode64(content)
+        if attachment.key?(:content)
+          attachment[:content] = encoded_content
+        else
+          attachment["content"] = encoded_content
+        end
+      end
+    end
+
+    # Create a StringIO object that behaves more like a File for HTTParty compatibility
+    def create_file_like_stringio(content)
+      # Content is already normalized to ASCII-8BIT by normalize_multipart_encodings!
+      # Create StringIO with the normalized binary content
+      string_io = StringIO.new(content)
+
+      # Add methods that HTTParty/multipart-post might expect
+      string_io.define_singleton_method(:path) { nil }
+      string_io.define_singleton_method(:local_path) { nil }
+      string_io.define_singleton_method(:respond_to_missing?) do |method_name, include_private = false|
+        File.instance_methods.include?(method_name) || super(method_name, include_private)
+      end
+
+      # Set binary mode for file-like behavior
+      string_io.binmode if string_io.respond_to?(:binmode)
+
+      string_io
     end
 
     def setup_http(path, timeout, headers, query, api_key)
@@ -206,37 +312,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/folders.rb

@@ -15,6 +15,11 @@ module Nylas
     #
     # @param identifier [String] Grant ID or email account to query.
     # @param query_params [Hash, nil] Query params to pass to the request.
+    #   Supported parameters include:
+    #   - single_level: (Boolean) For Microsoft accounts only. If true, retrieves folders from
+    #     a single-level hierarchy only. If false (default), retrieves folders across a
+    #     multi-level hierarchy.
+    #   - include_hidden_folders [Boolean] (Microsoft only) When true, includes hidden folders.
     # @return [Array(Array(Hash), String, String)] The list of folders, API Request ID, and next cursor.
     def list(identifier:, query_params: nil)
       get_list(

data/lib/nylas/resources/messages.rb

@@ -126,7 +126,7 @@ module Nylas
         request_body: payload
       )
 
-      opened_files.each(&:close)
+      opened_files.each { |file| file.close if file.respond_to?(:close) }
 
       response
     end

data/lib/nylas/resources/webhooks.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "cgi"
 require_relative "resource"
 require_relative "../handler/api_operations"
 

data/lib/nylas/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nylas
 version: !ruby/object:Gem::Version
-  version: 6.5.0
+  version: 6.7.0
 platform: ruby
 authors:
 - Nylas, Inc.
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -295,7 +294,6 @@ files:
 - lib/nylas/resources/webhooks.rb
 - lib/nylas/utils/file_utils.rb
 - lib/nylas/version.rb
-homepage:
 licenses:
 - MIT
 metadata:
@@ -305,7 +303,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 +317,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Gem for interacting with the Nylas API
 test_files: []