nylas 6.4.0 → 6.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 275a09b48ad361ba1f441efa8b32a026fa547c0296ea3b681da440e6c7652516
-  data.tar.gz: 813293f38fabeb6cbfae1a9974a6e27622c68352442982a49890c176c354a2d5
+  metadata.gz: b88e46de5b92ca56b82971334bc996b373407c76612b7ae7cf560a6496c5fb57
+  data.tar.gz: 25caea97521efd4fd2f903eed63b375b91a47142c797fd109cb60169a4d51920
 SHA512:
-  metadata.gz: 3453ab99f8e2ab3bec6abd2f2cad0c8ea0d43e26a328eb3ff318b2c250f3cc4d699396c7638648118f4b2af47d37aca767f4106ad04dc5a0858b2c99f6814d5e
-  data.tar.gz: 236711014f51f24b29c64fbe578cf0eea851cb44bb486dec3ec39c73a9311cb84a42d1f78d5c29e5eeae8025aef154e9e2ae74789fc50c9b5ebfe39eb9226a93
+  metadata.gz: 4af7e805753ad3df593249379933f58cfc42b25c962fafbfae041554d87fe66d59dd4ee1b18475bcf0c69e65dcfe57f1a384d9e9289e9c74fbda20b92d568fb6
+  data.tar.gz: 704f122a8273212641bcb02c4b1dd6b225d00f64f23655cd3c35ec81d654e1c1e6585d44a99a7caf7a991f4ee8f3fc6f05c61008cc1496b4c2f5fc5521ee9c28

data/lib/nylas/handler/http_client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "rest-client"
+require "httparty"
+require "net/http"
 
 require_relative "../errors"
 require_relative "../version"
@@ -34,18 +35,18 @@ module Nylas
       request = build_request(method: method, path: path, headers: headers,
                               query: query, payload: payload, api_key: api_key, timeout: timeout)
       begin
-        rest_client_execute(**request) do |response, _request, result|
+        httparty_execute(**request) do |response, _request, result|
           content_type = nil
-          if response.headers && response.headers[:content_type]
-            content_type = response.headers[:content_type].downcase
+          if response.headers && response.headers["content-type"]
+            content_type = response.headers["content-type"].downcase
           end
 
-          parsed_response = parse_json_evaluate_error(result.code.to_i, response, path, content_type)
+          parsed_response = parse_json_evaluate_error(result.code.to_i, response.body, path, content_type)
           # Include headers in the response
           parsed_response[:headers] = response.headers unless parsed_response.nil?
           parsed_response
         end
-      rescue RestClient::Exceptions::OpenTimeout, RestClient::Exceptions::ReadTimeout
+      rescue Net::OpenTimeout, Net::ReadTimeout
         raise Nylas::NylasSdkTimeoutError.new(request[:path], timeout)
       end
     end
@@ -97,11 +98,18 @@ module Nylas
     )
       url = build_url(path, query)
       resulting_headers = default_headers.merge(headers).merge(auth_header(api_key))
-      if !payload.nil? && !payload["multipart"]
+
+      # Check for multipart flag using both string and symbol keys for backwards compatibility
+      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 !payload.nil? && payload["multipart"]
+      elsif is_multipart
+        # Remove multipart flag from both possible key types
         payload.delete("multipart")
+        payload.delete(:multipart)
       end
 
       { method: method, url: url, payload: payload, headers: resulting_headers, timeout: timeout }
@@ -126,16 +134,156 @@ module Nylas
 
     private
 
-    # Sends a request to the Nylas REST API.
+    # Sends a request to the Nylas REST API using HTTParty.
     #
     # @param method [Symbol] HTTP method for the API call. Either :get, :post, :delete, or :patch.
     # @param url [String] URL for the API call.
     # @param headers [Hash] HTTP headers to include in the payload.
     # @param payload [String, Hash] Body to send with the request.
     # @param timeout [Hash] Timeout value to send with the request.
-    def rest_client_execute(method:, url:, headers:, payload:, timeout:, &block)
-      ::RestClient::Request.execute(method: method, url: url, payload: payload,
-                                    headers: headers, timeout: timeout, &block)
+    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
+      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
+        response
+      end
+    end
+
+    # Create a response wrapper that mimics RestClient::Response.code behavior
+    def create_response_wrapper(response)
+      OpenStruct.new(code: response.code)
+    end
+
+    # Check if payload contains file uploads
+    def file_upload?(payload)
+      return false unless payload.is_a?(Hash)
+
+      # 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)

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

@@ -6,6 +6,19 @@ require_relative "../handler/api_operations"
 require_relative "../utils/file_utils"
 
 module Nylas
+  # Module representing the possible 'fields' values for Messages API requests.
+  # @see https://developer.nylas.com/docs/api/messages#get-/v3/grants/-identifier-/messages
+  module MessageFields
+    # Return the standard message payload (default)
+    STANDARD = "standard"
+    # Return messages and their custom headers
+    INCLUDE_HEADERS = "include_headers"
+    # Return messages and their tracking settings
+    INCLUDE_TRACKING_OPTIONS = "include_tracking_options"
+    # Return the grant_id, object, id, and raw_mime fields only
+    RAW_MIME = "raw_mime"
+  end
+
   # Nylas Messages API
   class Messages < Resource
     include ApiOperations::Get
@@ -26,6 +39,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.
+    #   You can use the fields parameter to specify which data to return:
+    #   - MessageFields::STANDARD (default): Returns the standard message payload
+    #   - MessageFields::INCLUDE_HEADERS: Returns messages and their custom headers
+    #   - MessageFields::INCLUDE_TRACKING_OPTIONS: Returns messages and their tracking settings
+    #   - MessageFields::RAW_MIME: Returns the grant_id, object, id, and raw_mime fields only
     # @return [Array(Array(Hash), String, String)] The list of messages, API Request ID, and next cursor.
     def list(identifier:, query_params: nil)
       get_list(
@@ -39,6 +57,11 @@ module Nylas
     # @param identifier [String] Grant ID or email account to query.
     # @param message_id [String] The id of the message to return.
     # @param query_params [Hash, nil] Query params to pass to the request.
+    #   You can use the fields parameter to specify which data to return:
+    #   - MessageFields::STANDARD (default): Returns the standard message payload
+    #   - MessageFields::INCLUDE_HEADERS: Returns messages and their custom headers
+    #   - MessageFields::INCLUDE_TRACKING_OPTIONS: Returns messages and their tracking settings
+    #   - MessageFields::RAW_MIME: Returns the grant_id, object, id, and raw_mime fields only
     # @return [Array(Hash, String)] The message and API request ID.
     def find(identifier:, message_id:, query_params: nil)
       get(
@@ -103,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.4.0"
+  VERSION = "6.6.0"
 end

data/lib/nylas.rb

@@ -1,21 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
-require "rest-client"
-
-# BUGFIX
-#   See https://github.com/sparklemotion/http-cookie/issues/27
-#   and https://github.com/sparklemotion/http-cookie/issues/6
-#
-# CookieJar uses unsafe class caching for dynamically loading cookie jars.
-# If two rest-client instances are instantiated at the same time (in threads), non-deterministic
-# behaviour can occur whereby the Hash cookie jar isn't properly loaded and cached.
-# Forcing an instantiation of the jar onload will force the CookieJar to load before the system has
-# a chance to spawn any threads.
-# Note that this should technically be fixed in rest-client itself, however that library appears to
-# be stagnant so we're forced to fix it here.
-# This object should get GC'd as it's not referenced by anything.
-HTTP::CookieJar.new
+require "httparty"
 
 require "ostruct"
 require "forwardable"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nylas
 version: !ruby/object:Gem::Version
-  version: 6.4.0
+  version: 6.6.0
 platform: ruby
 authors:
 - Nylas, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-30 00:00:00.000000000 Z
+date: 2025-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
 - !ruby/object:Gem::Dependency
   name: mime-types
   requirement: !ruby/object:Gem::Requirement
@@ -58,26 +72,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.6'
-- !ruby/object:Gem::Dependency
-  name: rest-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement