nylas 6.7.0 → 6.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc90a16ef74fc2f47d6f35ada72d9cd80e3e842e08d9d5b1916a819ae36c0808
-  data.tar.gz: b2c8494899f1b2ff4620dfbcce0aeb52e037adfe97f1609bcaaf455bfb843745
+  metadata.gz: 39fb36891572d67e348da1b79d8d0f73c0c542f073252733a17c7a11ac5f041b
+  data.tar.gz: 234c99ad89acd1ef2069bea31a70f7f86e8acf8e5b6a0a38b6000e79e7a570e4
 SHA512:
-  metadata.gz: c9cda94765c3957d6457071ac616dd12a3a807378773b566da0be82b39c5a89db370049f21744b91ed8f3a5abf211b6c75363f8df10f52d102007becfcd2a635
-  data.tar.gz: e50d00d31fdb2ae23058d146b38cc75a5a75f239ba19220b5c28280defe4624b4ab4d858ec3abd496555ab6b0f35033ac2c606ed2bc346572f0593df0cebb5cc
+  metadata.gz: ae326a217e211366f66a2079cc98990c9ebad04bd0c48a88c6a1634adae55db6d9ee505060655eb4faee1a2deffb7d4447e007a5e5b09a3fdc44157743b20034
+  data.tar.gz: b5c494daa9bd4062765eb5182382f550d06abb20ee85d0c890dee54cede76af4ea5650765ebd9bc3bb151d404bb853b409e9695219a5bcf29156d27df6fd696d

data/lib/nylas/client.rb

@@ -8,6 +8,7 @@ require_relative "resources/auth"
 require_relative "resources/webhooks"
 require_relative "resources/applications"
 require_relative "resources/folders"
+require_relative "resources/lists"
 require_relative "resources/notetakers"
 require_relative "resources/scheduler"
 
@@ -99,6 +100,13 @@ module Nylas
       Grants.new(self)
     end
 
+    # The list resources for your Nylas application.
+    #
+    # @return [Nylas::Lists] List resources for your Nylas application
+    def lists
+      Lists.new(self)
+    end
+
     # The message resources for your Nylas application.
     #
     # @return [Nylas::Messages] Message resources for your Nylas application
@@ -113,6 +121,34 @@ module Nylas
       Threads.new(self)
     end
 
+    # The policy resources for your Nylas application.
+    #
+    # @return [Nylas::Policies] Policy resources for your Nylas application.
+    def policies
+      Policies.new(self)
+    end
+
+    # The rule resources for your Nylas application.
+    #
+    # @return [Nylas::Rules] Rule resources for your Nylas application.
+    def rules
+      Rules.new(self)
+    end
+
+    # The workspace resources for your Nylas application.
+    #
+    # @return [Nylas::Workspaces] Workspace resources for your Nylas application.
+    def workspaces
+      Workspaces.new(self)
+    end
+
+    # The domain resources for your Nylas application.
+    #
+    # @return [Nylas::Domains] Domain resources for your Nylas application.
+    def domains
+      Domains.new(self)
+    end
+
     # The webhook resources for your Nylas application.
     #
     # @return [Nylas::Webhooks] Webhook resources for your Nylas application.

data/lib/nylas/handler/api_operations.rb

@@ -15,9 +15,10 @@ module Nylas
       #
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return [Array([Hash, Array], String, Hash)] Nylas data object, API Request ID, and response headers.
-      def get(path:, query_params: {})
-        response = get_raw(path: path, query_params: query_params)
+      def get(path:, query_params: {}, headers: {})
+        response = get_raw(path: path, query_params: query_params, headers: headers)
 
         [response[:data], response[:request_id], response[:headers]]
       end
@@ -26,10 +27,11 @@ module Nylas
       #
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return [Array<Array<Hash>, String, String, Hash>]
       #   Nylas data array, API Request ID, next cursor, and response headers.response headers.
-      def get_list(path:, query_params: {})
-        response = get_raw(path: path, query_params: query_params)
+      def get_list(path:, query_params: {}, headers: {})
+        response = get_raw(path: path, query_params: query_params, headers: headers)
 
         [response[:data], response[:request_id], response[:next_cursor], response[:headers]]
       end
@@ -40,16 +42,20 @@ module Nylas
       #
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return [Hash] The JSON response from the Nylas API.
-      def get_raw(path:, query_params: {})
-        execute(
+      def get_raw(path:, query_params: {}, headers: {})
+        request = {
           method: :get,
           path: path,
           query: query_params,
           payload: nil,
           api_key: api_key,
           timeout: timeout
-        )
+        }
+        request[:headers] = headers unless headers.empty?
+
+        execute(**request)
       end
     end
 
@@ -63,18 +69,21 @@ module Nylas
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
       # @param request_body [Hash, nil] Request body to pass to the call.
+      #   Defaults to {} when nil to ensure Content-Type: application/json is sent.
       # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return [Array(Hash, String, Hash)] Nylas data object, API Request ID, and response headers.
-      def post(path:, query_params: {}, request_body: nil, headers: {})
-        response = execute(
+      def post(path:, query_params: {}, request_body: nil, headers: {}, serialized_json_body: nil)
+        request = {
           method: :post,
           path: path,
           query: query_params,
-          payload: request_body,
+          payload: request_body || {},
           headers: headers,
           api_key: api_key,
           timeout: timeout
-        )
+        }
+        request[:serialized_json_body] = serialized_json_body unless serialized_json_body.nil?
+        response = execute(**request)
 
         [response[:data], response[:request_id], response[:headers]]
       end
@@ -90,18 +99,21 @@ module Nylas
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
       # @param request_body [Hash, nil] Request body to pass to the call.
+      #   Defaults to {} when nil to ensure Content-Type: application/json is sent.
       # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return Nylas data object and API Request ID.
-      def put(path:, query_params: {}, request_body: nil, headers: {})
-        response = execute(
+      def put(path:, query_params: {}, request_body: nil, headers: {}, serialized_json_body: nil)
+        request = {
           method: :put,
           path: path,
           query: query_params,
-          payload: request_body,
+          payload: request_body || {},
           headers: headers,
           api_key: api_key,
           timeout: timeout
-        )
+        }
+        request[:serialized_json_body] = serialized_json_body unless serialized_json_body.nil?
+        response = execute(**request)
 
         [response[:data], response[:request_id]]
       end
@@ -117,18 +129,21 @@ module Nylas
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
       # @param request_body [Hash, nil] Request body to pass to the call.
+      #   Defaults to {} when nil to ensure Content-Type: application/json is sent.
       # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return Nylas data object and API Request ID.
-      def patch(path:, query_params: {}, request_body: nil, headers: {})
-        response = execute(
+      def patch(path:, query_params: {}, request_body: nil, headers: {}, serialized_json_body: nil)
+        request = {
           method: :patch,
           path: path,
           query: query_params,
-          payload: request_body,
+          payload: request_body || {},
           headers: headers,
           api_key: api_key,
           timeout: timeout
-        )
+        }
+        request[:serialized_json_body] = serialized_json_body unless serialized_json_body.nil?
+        response = execute(**request)
 
         [response[:data], response[:request_id]]
       end
@@ -143,15 +158,17 @@ module Nylas
       #
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param request_body [Hash, nil] Optional request body (e.g. cancellation_reason for bookings).
+      #   Defaults to {} to ensure Content-Type: application/json is sent.
       # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return Nylas data object and API Request ID.
-      def delete(path:, query_params: {}, headers: {})
+      def delete(path:, query_params: {}, request_body: nil, headers: {})
         response = execute(
           method: :delete,
           path: path,
           query: query_params,
           headers: headers,
-          payload: nil,
+          payload: request_body || {},
           api_key: api_key,
           timeout: timeout
         )

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"
@@ -29,11 +30,14 @@ module Nylas
     # @param query [Hash, {}] Hash of names and values to include in the query section of the URI
     # fragment.
     # @param payload [Hash, nil] Body to send with the request.
+    # @param serialized_json_body [String, nil] Pre-serialized JSON body to send as-is.
     # @param api_key [Hash, nil] API key to send with the request.
     # @return [Object] Parsed JSON response from the API.
-    def execute(method:, path:, timeout:, headers: {}, query: {}, payload: nil, api_key: nil)
+    def execute(method:, path:, timeout:, headers: {}, query: {}, payload: nil, api_key: nil,
+                serialized_json_body: nil)
       request = build_request(method: method, path: path, headers: headers,
-                              query: query, payload: payload, api_key: api_key, timeout: timeout)
+                              query: query, payload: payload, api_key: api_key, timeout: timeout,
+                              serialized_json_body: serialized_json_body)
       begin
         httparty_execute(**request) do |response, _request, result|
           content_type = nil
@@ -90,12 +94,14 @@ module Nylas
     # @param query [Hash, {}] Hash of names and values to include in the query section of the URI
     # fragment.
     # @param payload [Hash, nil] Body to send with the request.
+    # @param serialized_json_body [String, nil] Pre-serialized JSON body to send as-is.
     # @param timeout [Integer, nil] Timeout value to send with the request.
     # @param api_key [Hash, nil] API key to send with the request.
     # @return [Object] The request information after processing. This includes an updated payload
     # and headers.
     def build_request(
-      method:, path: nil, headers: {}, query: {}, payload: nil, timeout: nil, api_key: nil
+      method:, path: nil, headers: {}, query: {}, payload: nil, timeout: nil, api_key: nil,
+      serialized_json_body: nil
     )
       url = build_url(path, query)
       resulting_headers = default_headers.merge(headers).merge(auth_header(api_key))
@@ -103,7 +109,10 @@ module Nylas
       # 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
+      if !serialized_json_body.nil?
+        payload = serialized_json_body
+        resulting_headers["Content-type"] = "application/json"
+      elsif !payload.nil? && !is_multipart
         normalize_json_encodings!(payload)
         payload = payload&.to_json
         resulting_headers["Content-type"] = "application/json"
@@ -135,7 +144,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.
@@ -143,25 +154,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
@@ -169,6 +171,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)
@@ -188,10 +261,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
 
@@ -414,6 +497,8 @@ module Nylas
 
     # Set the authorization header for an API query.
     def auth_header(api_key)
+      return {} if api_key.nil?
+
       { "Authorization" => "Bearer #{api_key}" }
     end
   end

data/lib/nylas/handler/service_account_signer.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "openssl"
+require "securerandom"
+
+module Nylas
+  # Builds Nylas Service Account request signing headers for organization admin APIs.
+  #
+  # @see https://developer.nylas.com/docs/v3/auth/nylas-service-account/
+  class ServiceAccountSigner
+    NONCE_ALPHABET = ("a".."z").to_a.concat(("A".."Z").to_a, ("0".."9").to_a).freeze
+    DEFAULT_NONCE_LENGTH = 20
+    SIGNED_BODY_METHODS = %w[post put patch].freeze
+
+    attr_reader :private_key_id
+
+    # @param private_key_pem [String] RSA private key in PEM format.
+    # @param private_key_id [String] Value for the X-Nylas-Kid header.
+    def initialize(private_key_pem:, private_key_id:)
+      @private_key = self.class.load_rsa_private_key(private_key_pem)
+      @private_key_id = private_key_id
+    end
+
+    # Returns deterministic JSON with keys sorted at every object level and no extra whitespace.
+    #
+    # @param data [Hash, Array, String, Numeric, true, false, nil] Data to serialize.
+    # @return [String] Canonical JSON string.
+    def self.canonical_json(data)
+      JSON.generate(canonicalize(data))
+    end
+
+    # Loads an RSA private key from a PEM string.
+    #
+    # @param private_key_pem [String] RSA private key in PEM format.
+    # @return [OpenSSL::PKey::RSA]
+    def self.load_rsa_private_key(private_key_pem)
+      key = OpenSSL::PKey::RSA.new(private_key_pem)
+      raise ArgumentError, "Private key must be RSA private key" unless key.private?
+      raise ArgumentError, "Private key must be at least 2048 bits" if key.n.num_bits < 2048
+
+      key
+    rescue OpenSSL::PKey::PKeyError
+      raise ArgumentError, "Private key must be RSA PEM"
+    end
+
+    # Generates a cryptographically secure alphanumeric nonce.
+    #
+    # @param length [Integer] Length of the nonce to generate.
+    # @return [String] Generated nonce.
+    def self.generate_nonce(length = DEFAULT_NONCE_LENGTH)
+      Array.new(length) { NONCE_ALPHABET[SecureRandom.random_number(NONCE_ALPHABET.length)] }.join
+    end
+
+    # Builds signed headers and, for JSON body methods, the exact canonical body to send.
+    #
+    # @param method [String, Symbol] HTTP method.
+    # @param path [String] Relative request path, for example "/v3/admin/domains".
+    # @param body [Hash, nil] Request body for POST/PUT/PATCH requests.
+    # @param timestamp [Integer, nil] Optional Unix timestamp in seconds, mainly for tests.
+    # @param nonce [String, nil] Optional nonce, mainly for tests.
+    # @return [Array(Hash, String)] Signed headers and optional serialized JSON body.
+    def build_headers(method:, path:, body: nil, timestamp: nil, nonce: nil)
+      timestamp ||= Time.now.to_i
+      nonce ||= self.class.generate_nonce
+      method_value = method.to_s.downcase
+      serialized_body = nil
+
+      if SIGNED_BODY_METHODS.include?(method_value) && !body.nil?
+        serialized_body = self.class.canonical_json(body)
+      end
+
+      envelope = {
+        method: method_value,
+        nonce: nonce,
+        path: path,
+        timestamp: timestamp
+      }
+      envelope[:payload] = serialized_body if serialized_body
+
+      signature = @private_key.sign(OpenSSL::Digest.new("SHA256"), self.class.canonical_json(envelope))
+
+      [
+        {
+          "X-Nylas-Kid" => private_key_id,
+          "X-Nylas-Nonce" => nonce,
+          "X-Nylas-Timestamp" => timestamp.to_s,
+          "X-Nylas-Signature" => Base64.strict_encode64(signature)
+        },
+        serialized_body
+      ]
+    end
+
+    class << self
+      private
+
+      def canonicalize(value)
+        case value
+        when Hash
+          value.keys.sort_by(&:to_s).each_with_object({}) do |key, result|
+            result[key.to_s] = canonicalize(value[key])
+          end
+        when Array
+          value.map { |item| canonicalize(item) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/nylas/resources/applications.rb

@@ -8,6 +8,7 @@ module Nylas
   # Application
   class Applications < Resource
     include ApiOperations::Get
+    include ApiOperations::Patch
 
     attr_reader :redirect_uris
 
@@ -23,5 +24,18 @@ module Nylas
     def get_details
       get(path: "#{api_uri}/v3/applications")
     end
+
+    # Update application details.
+    #
+    # @param request_body [Hash] The values to update the application with. Include
+    #   +callback_uris+ entries with +id+ when preserving or updating existing
+    #   callback URIs.
+    # @return [Array(Hash, String)] The updated application details and API Request ID.
+    def update(request_body:)
+      patch(
+        path: "#{api_uri}/v3/applications",
+        request_body: request_body
+      )
+    end
   end
 end

data/lib/nylas/resources/bookings.rb

@@ -64,11 +64,13 @@ module Nylas
     # Delete a booking.
     # @param booking_id [String] The id of the booking to delete.
     # @param query_params [Hash, nil] Query params to pass to the request.
+    # @param request_body [Hash, nil] Optional body params (e.g. cancellation_reason).
     # @return [Array(TrueClass, String)] True and the API Request ID for the delete operation.
-    def destroy(booking_id:, query_params: nil)
+    def destroy(booking_id:, query_params: nil, request_body: nil)
       _, request_id = delete(
         path: "#{api_uri}/v3/scheduling/bookings/#{booking_id}",
-        query_params: query_params
+        query_params: query_params,
+        request_body: request_body
       )
 
       [true, request_id]