nylas 5.17.0 → 6.0.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0660c04f6656d846a55819153819877b599ed5342d8f2ea9c18a7b19e0799ec3
-  data.tar.gz: bf1bd6d4382a6705a5146ff86202436512cf0fc5c68817c77a932e846c3150cf
+  metadata.gz: 6fa40920f9d190cc73e988935bdd235ad3a4bb342c8762be925fdb81f8c1c45f
+  data.tar.gz: 6bf0722aae4e7b9699abeda1e25436ac62256aa7c14a1f9d330eff2d8908c9c6
 SHA512:
-  metadata.gz: 076702b69e4ea6a7ef882f3ac65490d54c90bae69cdc8f940aab62a4d29997627d7936b3426158e10935f1aecfad517e17b2d3c5502aa26a636e48319c492fcd
-  data.tar.gz: 1d7fd956e5676c2b418ed2d0d79ecfd9cf3b6a961f8768ee0dd97952f0ea043810e90499063b1940efc055506a79187f78d4daf04fe386dfbdf64141bd1d9262
+  metadata.gz: 3fb796e62d9c6545d5632c0112ac328ee69ce0fbda26e82a31ce4adf790bea75096a172a7252a4b75da850cf6268a864ea6365137e40f8ff6e7682767bc7f3da
+  data.tar.gz: 13b91300931cc49f195f1a3ab01d5c72fe7100bf0c83dcfac5acdd965c0da4b2a7c547bc0611482916c3de8a6f7255604f9ca47f3894f94aba09a483da1f8c73

data/lib/nylas/client.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "resources/calendars"
+require_relative "resources/connectors"
+require_relative "resources/messages"
+require_relative "resources/events"
+require_relative "resources/auth"
+require_relative "resources/webhooks"
+require_relative "resources/applications"
+require_relative "resources/folders"
+
+module Nylas
+  # Methods to retrieve data from the Nylas API as Ruby objects.
+  class Client
+    attr_reader :api_key, :api_uri, :timeout
+
+    # Initializes a client session.
+    #
+    # @param api_key [String, nil] API key to use for the client session.
+    # @param api_uri [String] Client session's host.
+    # @param timeout [String, nil] Timeout value to use for the client session.
+    def initialize(api_key:,
+                   api_uri: Config::DEFAULT_REGION_URL,
+                   timeout: nil)
+      @api_key = api_key
+      @api_uri = api_uri
+      @timeout = timeout || 30
+    end
+
+    # The application resources for your Nylas application.
+    #
+    # @return [Nylas::Applications] Application resources for your Nylas application.
+    def applications
+      Applications.new(self)
+    end
+
+    # The attachments resources for your Nylas application.
+    #
+    # @return [Nylas::Attachments] Attachment resources for your Nylas application.
+    def attachments
+      Attachments.new(self)
+    end
+
+    # The auth resources for your Nylas application.
+    #
+    # @return [Nylas::Auth] Auth resources for your Nylas application.
+    def auth
+      Auth.new(self)
+    end
+
+    # The calendar resources for your Nylas application.
+    #
+    # @return [Nylas::Calendars] Calendar resources for your Nylas application.
+    def calendars
+      Calendars.new(self)
+    end
+
+    # The connector resources for your Nylas application.
+    #
+    # @return [Nylas::Connectors] Connector resources for your Nylas application.
+    def connectors
+      Connectors.new(self)
+    end
+
+    # The draft resources for your Nylas application.
+    #
+    # @return [Nylas::Drafts] Draft resources for your Nylas application.
+    def drafts
+      Drafts.new(self)
+    end
+
+    # The event resources for your Nylas application.
+    #
+    # @return [Nylas::Events] Event resources for your Nylas application
+    def events
+      Events.new(self)
+    end
+
+    # The folder resources for your Nylas application.
+    #
+    # @return [Nylas::Folder] Folder resources for your Nylas application
+    def folders
+      Folders.new(self)
+    end
+
+    # The message resources for your Nylas application.
+    #
+    # @return [Nylas::Messages] Message resources for your Nylas application
+    def messages
+      Messages.new(self)
+    end
+
+    # The thread resources for your Nylas application.
+    #
+    # @return [Nylas::Threads] Thread resources for your Nylas application.
+    def threads
+      Threads.new(self)
+    end
+
+    # The webhook resources for your Nylas application.
+    #
+    # @return [Nylas::Webhooks] Webhook resources for your Nylas application.
+    def webhooks
+      Webhooks.new(self)
+    end
+  end
+end

data/lib/nylas/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Configuration options for the Nylas Ruby SDK.
+  module Config
+    # The configuration options for supported regions.
+    REGION_CONFIG = {
+      us: {
+        nylas_api_url: "https://api.us.nylas.com"
+      },
+      eu: {
+        nylas_api_url: "https://api.eu.nylas.com"
+      }
+    }.freeze
+
+    # The default API endpoint for the Nylas API.
+    DEFAULT_REGION_URL = REGION_CONFIG[:us][:nylas_api_url]
+  end
+end

data/lib/nylas/errors.rb

@@ -3,109 +3,83 @@
 module Nylas
   Error = Class.new(::StandardError)
 
-  class ModelActionError < Error; end
-  class ModelNotFilterableError < ModelActionError; end
-  class ModelNotCreatableError < ModelActionError; end
-  class ModelNotShowableError < ModelActionError; end
-  class ModelNotAvailableAsRawError < ModelActionError; end
-  class ModelNotListableError < ModelActionError; end
-  class ModelNotFilterableError < ModelActionError; end
-  class ModelNotSearchableError < ModelActionError; end
-  class ModelNotUpdatableError < ModelActionError; end
-  class ModelNotDestroyableError < ModelActionError; end
-
-  class JsonParseError < Error; end
-
-  # Raised when attempting to set a field that is not on a model with mass assignment
-  class ModelMissingFieldError < ModelActionError
-    def initialize(field, model)
-      super("#{field} is not a valid attribute for #{model.class.name}")
-    end
-  end
-
-  # Indicates that a given method needs an access token to work.
-  class NoAuthToken < Error
-    def initialize(method_name)
-      super "No access token was provided and the #{method_name} method requires one"
-    end
-  end
-
-  UnexpectedAccountAction = Class.new(Error)
-  UnexpectedResponse = Class.new(Error)
-
-  # Base class to inflate the standard errors returned from the Nylas API
-  class APIError < Error
-    attr_accessor :type
-    attr_accessor :message
-    attr_accessor :server_error
-
-    def initialize(type, message, server_error = nil)
+  # Base error class for API-related errors.
+  class AbstractNylasApiError < Error; end
+
+  # Base error class for SDK-related errors.
+  class AbstractNylasSdkError < Error; end
+
+  # Error class representing a failed parse of a JSON response from the Nylas API.
+  class JsonParseError < AbstractNylasSdkError; end
+
+  # Error class representing a failed response from the Nylas API.
+  class NylasApiError < AbstractNylasApiError
+    attr_accessor :type, :request_id, :provider_error, :status_code
+
+    # Initializes an error and assigns the given attributes to it.
+    #
+    # @param type [Hash] Error type.
+    # @param message [String] Error message.
+    # @param status_code [Integer] Error status code.
+    # @param provider_error [String, nil] Provider error.
+    # @param request_id [Hash, nil] The ID of the request.
+    def initialize(type, message, status_code, provider_error = nil, request_id = nil)
       super(message)
       self.type = type
-      self.message = message
-      self.server_error = server_error
+      self.status_code = status_code
+      self.provider_error = provider_error
+      self.request_id = request_id
     end
 
-    def self.parse_error_response(response)
+    # Parses the error response.
+    #
+    # @param response [Hash] Response from the Nylas API.
+    # @param status_code [Integer] Error status code.
+    def self.parse_error_response(response, status_code)
       new(
         response["type"],
         response["message"],
-        response["server_error"]
+        status_code,
+        response["provider_error"]
       )
     end
   end
 
-  # Error class representing a 429 error response, with details on the rate limit
-  class RateLimitError < APIError
-    attr_accessor :rate_limit
-    attr_accessor :rate_limit_reset
-
-    RATE_LIMIT_LIMIT_HEADER = "x_ratelimit_limit"
-    RATE_LIMIT_RESET_HEADER = "x_ratelimit_reset"
-
-    def initialize(type, message, server_error = nil, rate_limit = nil, rate_limit_reset = nil)
-      super(type, message, server_error)
-      self.rate_limit = rate_limit
-      self.rate_limit_reset = rate_limit_reset
+  # Error class representing a failed response from the Nylas OAuth integration.
+  class NylasOAuthError < AbstractNylasApiError
+    attr_accessor :error, :error_description, :error_uri, :error_code, :status_code
+
+    # Initializes an error and assigns the given attributes to it.
+    #
+    # @param error [String] Error type.
+    # @param error_description [String] Description of the error.
+    # @param error_uri [String] Error URI.
+    # @param error_code [String] Error code.
+    # @param status_code [String] Error status code.
+    def initialize(error, error_description, error_uri, error_code, status_code)
+      super(error_description)
+      self.error = error
+      self.error_description = error_description
+      self.error_uri = error_uri
+      self.error_code = error_code
+      self.status_code = status_code
     end
+  end
 
-    def self.parse_error_response(response)
-      rate_limit, rate_limit_rest = extract_rate_limit_details(response)
-
-      new(
-        response["type"],
-        response["message"],
-        response["server_error"],
-        rate_limit,
-        rate_limit_rest
-      )
-    end
-
-    def self.extract_rate_limit_details(response)
-      return nil, nil unless response.respond_to?(:headers)
-
-      rate_limit = response.headers[RATE_LIMIT_LIMIT_HEADER.to_sym].to_i
-      rate_limit_rest = response.headers[RATE_LIMIT_RESET_HEADER.to_sym].to_i
-
-      [rate_limit, rate_limit_rest]
+  # Error class representing a timeout from the Nylas SDK.
+  class NylasSdkTimeoutError < AbstractNylasSdkError
+    attr_accessor :url, :timeout
+
+    # Initializes an error and assigns the given attributes to it.
+    # @param url [String] URL that timed out.
+    # @param timeout [Integer] Timeout in seconds.
+    # @return [NylasSdkTimeoutError] The error object.
+    def initialize(url, timeout)
+      super("Nylas SDK timed out before receiving a response from the server.")
+      self.url = url
+      self.timeout = timeout
     end
-
-    private_class_method :extract_rate_limit_details
   end
 
-  AccessDenied = Class.new(APIError)
-  ResourceNotFound = Class.new(APIError)
-  MethodNotAllowed = Class.new(APIError)
-  InvalidRequest = Class.new(APIError)
-  UnauthorizedRequest = Class.new(APIError)
-  ResourceRemoved = Class.new(APIError)
-  TeapotError = Class.new(APIError)
-  RequestTimedOut = Class.new(APIError)
-  MessageRejected = Class.new(APIError)
-  SendingQuotaExceeded = Class.new(RateLimitError)
-  ServiceUnavailable = Class.new(APIError)
-  BadGateway = Class.new(APIError)
-  InternalError = Class.new(APIError)
-  EndpointNotYetImplemented = Class.new(APIError)
-  MailProviderError = Class.new(APIError)
+  HTTP_SUCCESS_CODES = [200, 201, 202, 302].freeze
 end

data/lib/nylas/handler/api_operations.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "http_client"
+
+module Nylas
+  # Allows resources to perform API operations on the Nylas API endpoints without exposing the HTTP
+  # client to the end user.
+  module ApiOperations
+    # Performs a GET call to the Nylas API.
+    module Get
+      protected
+
+      include HttpClient
+      # Performs a GET call to the Nylas API.
+      #
+      # @param path [String] Destination path for the call.
+      # @param query_params [Hash, {}] Query params to pass to the call.
+      # @return Nylas data object and API Request ID.
+      def get(path:, query_params: {})
+        response = execute(
+          method: :get,
+          path: path,
+          query: query_params,
+          payload: nil,
+          api_key: api_key,
+          timeout: timeout
+        )
+
+        [response[:data], response[:request_id]]
+      end
+    end
+
+    # Performs a POST call to the Nylas API.
+    module Post
+      protected
+
+      include HttpClient
+      # Performs a POST call to the Nylas API.
+      #
+      # @param path [String] Destination path for the call.
+      # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param request_body [String, Hash, nil] Request body to pass to the call.
+      # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
+      # @return Nylas data object and API Request ID.
+      def post(path:, query_params: {}, request_body: nil, headers: {})
+        response = execute(
+          method: :post,
+          path: path,
+          query: query_params,
+          payload: request_body,
+          headers: headers,
+          api_key: api_key,
+          timeout: timeout
+        )
+
+        [response[:data], response[:request_id]]
+      end
+    end
+
+    # Performs a PUT call to the Nylas API.
+    module Put
+      protected
+
+      include HttpClient
+      # Performs a PUT call to the Nylas API.
+      #
+      # @param path [String] Destination path for the call.
+      # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param request_body [String, Hash, nil] Request body to pass to the call.
+      # @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(
+          method: :put,
+          path: path,
+          query: query_params,
+          payload: request_body,
+          headers: headers,
+          api_key: api_key,
+          timeout: timeout
+        )
+
+        [response[:data], response[:request_id]]
+      end
+    end
+
+    # Performs a PATCH call to the Nylas API.
+    module Patch
+      protected
+
+      include HttpClient
+      # Performs a PATCH call to the Nylas API.
+      #
+      # @param path [String] Destination path for the call.
+      # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param request_body [String, Hash, nil] Request body to pass to the call.
+      # @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(
+          method: :patch,
+          path: path,
+          query: query_params,
+          payload: request_body,
+          headers: headers,
+          api_key: api_key,
+          timeout: timeout
+        )
+
+        [response[:data], response[:request_id]]
+      end
+    end
+
+    # Performs a DELETE call to the Nylas API.
+    module Delete
+      protected
+
+      include HttpClient
+      # Performs a DELETE call to the Nylas API.
+      #
+      # @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 Nylas data object and API Request ID.
+      def delete(path:, query_params: {}, headers: {})
+        response = execute(
+          method: :delete,
+          path: path,
+          query: query_params,
+          headers: headers,
+          payload: nil,
+          api_key: api_key,
+          timeout: timeout
+        )
+
+        [response[:data], response[:request_id]]
+      end
+    end
+  end
+end