nylas 4.0.0.rc2 → 4.0.0.rc3

data/lib/nylas/current_account.rb

@@ -3,10 +3,7 @@ module Nylas
   # @see https://docs.nylas.com/reference#account
   class CurrentAccount
     include Model
-
-    self.read_only = true
-    self.searchable = false
-    self.collectionable = false
+    self.showable = true
 
     self.resources_path = "/account"
 

data/lib/nylas/delta.rb

@@ -0,0 +1,46 @@
+module Nylas
+  # Ruby object to represent a single change. Used both when receiving a webhook, as well as the deltas API.
+  # @see https://docs.nylas.com/reference#receiving-notifications
+  # @see https://docs.nylas.com/reference#deltas
+  class Delta
+    include Model::Attributable
+    attribute :id, :string
+    attribute :type, :string
+    attribute :object, :string
+    attribute :event, :string
+    attribute :cursor, :string
+    attribute :namespace_id, :string
+    attribute :account_id, :string
+
+    attribute :date, :unix_timestamp
+    attribute :metadata, :hash
+    attribute :object_attributes, :hash
+
+    def model
+      return nil if object.nil?
+      @model ||= Types.registry[object.to_sym].cast(object_attributes_with_ids)
+    end
+
+    def object_attributes_with_ids
+      (object_attributes || {}).merge(id: id, account_id: account_id)
+    end
+  end
+
+  # Casts Delta data from either a webhook or a delta stream to a Delta
+  class DeltaType < Types::ModelType
+    def initialize
+      super(model: Delta)
+    end
+
+    def cast(data)
+      data = if data.key?(:object_data)
+               object_data = data.delete(:object_data)
+               data.merge(object_data)
+             else
+               data
+             end
+      data[:object_attributes] = data.delete(:attributes)
+      super(data)
+    end
+  end
+end

data/lib/nylas/deltas.rb

@@ -0,0 +1,17 @@
+module Nylas
+  # Ruby object to represent a collection of changes. Used both when receiving a webhook, as well as the
+  # deltas API.
+  # @see https://docs.nylas.com/reference#receiving-notifications
+  # @see https://docs.nylas.com/reference#deltas
+  class Deltas
+    include Model
+    self.resources_path = "/delta"
+    allows_operations(filterable: true)
+    has_n_of_attribute :deltas, :delta
+    attribute :cursor_start, :string
+    attribute :cursor_end, :string
+
+    extend Forwardable
+    def_delegators :deltas, :count, :length, :each, :map, :first, :to_a, :empty?
+  end
+end

data/lib/nylas/deltas_collection.rb

@@ -0,0 +1,36 @@
+module Nylas
+  # Special collection for delta objects
+  class DeltasCollection < Collection
+    attr_accessor :deltas
+    extend Forwardable
+    def_delegators :execute, :cursor_start, :cursor_end,
+                   :count, :each, :to_h, :to_a, :empty?
+
+    def initialize(api:, constraints: nil, model: Deltas)
+      super(api: api, model: model, constraints: constraints)
+    end
+
+    def latest_cursor
+      api.execute(method: :post, path: "#{resources_path}/latest_cursor")[:cursor]
+    end
+
+    def latest
+      since(latest_cursor)
+    end
+
+    def since(cursor)
+      where(cursor: cursor)
+    end
+
+    def next_page(*)
+      return nil if empty?
+      where(cursor: cursor_end)
+    end
+
+    # Retrieves the data from the API for the particular constraints
+    # @return [Detlas]
+    def execute
+      self.deltas ||= Deltas.new(api.execute(to_be_executed))
+    end
+  end
+end

data/lib/nylas/draft.rb

@@ -0,0 +1,51 @@
+module Nylas
+  # Ruby representatin of a Nylas Draft object
+  # @see https://docs.nylas.com/reference#drafts
+  class Draft
+    include Model
+    self.resources_path = "/drafts"
+    allows_operations(creatable: true, showable: true, listable: true, updatable: true, destroyable: true)
+
+    attribute :id, :string
+    attribute :object, :string
+    attribute :version, :integer
+    attribute :account_id, :string
+    attribute :thread_id, :string
+    attribute :reply_to_message_id, :string
+
+    has_n_of_attribute :to, :email_address
+    has_n_of_attribute :from, :email_address
+    has_n_of_attribute :cc, :email_address
+    has_n_of_attribute :bcc, :email_address
+    has_n_of_attribute :reply_to, :email_address
+
+    attribute :date, :unix_timestamp
+    attribute :subject, :string
+    attribute :snippet, :string
+    attribute :body, :string
+    attribute :starred, :boolean
+    attribute :unread, :boolean
+
+    has_n_of_attribute :events, :event
+    has_n_of_attribute :files, :file
+    attribute :folder, :label
+    has_n_of_attribute :labels, :label
+
+    def send!
+      save
+      execute(method: :post, path: "/send", payload: JSON.dump(draft_id: id, version: version))
+    end
+
+    def starred?
+      starred
+    end
+
+    def unread?
+      unread
+    end
+
+    def destroy
+      execute(method: :delete, path: resource_path, payload: attributes.serialize(keys: [:version]))
+    end
+  end
+end

data/lib/nylas/email_address.rb

@@ -5,10 +5,6 @@ module Nylas
     include Model::Attributable
     attribute :type, :string
     attribute :email, :string
-  end
-
-  # Serializes, Deserializes between {EmailAddress} objects and a {Hash}
-  class EmailAddressType < Types::HashType
-    casts_to EmailAddress
+    attribute :name, :string
   end
 end

data/lib/nylas/errors.rb

@@ -1,6 +1,17 @@
 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
+
   # Indicates that a given method needs an access token to work.
   class NoAuthToken < Error
     def initialize(method_name)
@@ -26,11 +37,13 @@ module Nylas
   end
   AccessDenied = Class.new(APIError)
   ResourceNotFound = Class.new(APIError)
+  MethodNotAllowed = Class.new(APIError)
   InvalidRequest = Class.new(APIError)
   MessageRejected = Class.new(APIError)
   SendingQuotaExceeded = Class.new(APIError)
   ServiceUnavailable = Class.new(APIError)
   BadGateway = Class.new(APIError)
   InternalError = Class.new(APIError)
+  EndpointNotYetImplemented = Class.new(APIError)
   MailProviderError = Class.new(APIError)
 end

data/lib/nylas/event.rb

@@ -0,0 +1,42 @@
+module Nylas
+  # Structure to represent a the Event Schema.
+  # @see https://docs.nylas.com/reference#events
+  class Event
+    include Model
+    self.resources_path = "/events"
+    allows_operations(creatable: true, listable: true, filterable: true, showable: true, updatable: true,
+                      destroyable: true)
+
+    attribute :id, :string
+    attribute :object, :string
+    attribute :account_id, :string
+    attribute :calendar_id, :string
+    attribute :master_event_id, :string
+    attribute :message_id, :string
+
+    attribute :busy, :boolean
+    attribute :description, :string
+    attribute :location, :string
+    attribute :owner, :string
+    attribute :recurrence, :recurrence
+    has_n_of_attribute :participants, :participant
+    attribute :read_only, :boolean
+    attribute :status, :string
+    attribute :title, :string
+    attribute :when, :timespan
+
+    def busy?
+      busy
+    end
+
+    def read_only?
+      read_only
+    end
+
+    def rsvp(status, notify_participants:)
+      rsvp = Rsvp.new(api: api, status: status, notify_participants: notify_participants,
+                      event_id: id, account_id: account_id)
+      rsvp.save
+    end
+  end
+end

data/lib/nylas/event_collection.rb

@@ -0,0 +1,13 @@
+module Nylas
+  # Syntactical sugar methods for some of the Event's filters
+  # @see https://docs.nylas.com/reference#get-events
+  class EventCollection < Collection
+    def expand_recurring
+      where(expand_recurring: true)
+    end
+
+    def show_cancelled
+      where(show_cancelled: true)
+    end
+  end
+end

data/lib/nylas/file.rb

@@ -0,0 +1,58 @@
+module Nylas
+  # Structure to represent a the File Schema.
+  # @see https://docs.nylas.com/reference#events
+  class File
+    include Model
+    self.resources_path = "/files"
+    allows_operations(listable: true, showable: true, filterable: true, creatable: true)
+
+    attribute :id, :string
+    attribute :account_id, :string
+    attribute :content_id, :string
+    has_n_of_attribute :message_ids, :string
+
+    attribute :object, :string
+
+    attribute :content_type, :string
+    attribute :filename, :string
+    attribute :size, :integer
+
+    attr_accessor :file
+    # Downloads and caches a local copy of the file.
+    # @return [Tempfile] - Local copy of the file
+    def download
+      return file if file
+      self.file = retrieve_file
+    end
+
+    # Redownloads a file even if it's been cached. Closes and unlinks the tempfile to help memory usage.
+    def download!
+      return download if file.nil?
+      file.close
+      file.unlink
+      self.file = nil
+      download
+    end
+
+    def create
+      save
+    end
+
+    def save
+      raise ModelNotUpdatableError if persisted?
+      response = api.execute(path: "/files", method: :post, headers: { multipart: true },
+                             payload: { file: file })
+      attributes.merge(response.first)
+      true
+    end
+
+    private def retrieve_file
+      response = api.get(path: "#{resource_path}/download")
+      filename = response.headers.fetch(:content_disposition, "").gsub("attachment; filename=", "")
+      temp_file = Tempfile.new(filename)
+      temp_file.write(response.body)
+      temp_file.seek(0)
+      temp_file
+    end
+  end
+end

data/lib/nylas/folder.rb

@@ -0,0 +1,22 @@
+module Nylas
+  # Structure to represent the Folder Schema
+  # @see https://docs.nylas.com/reference#folders
+  class Folder
+    include Model
+    self.resources_path = "/folders"
+    self.creatable = true
+    self.listable = true
+    self.showable = true
+    self.filterable = false
+    self.updatable = true
+    self.destroyable = true
+
+    attribute :id, :string
+    attribute :account_id, :string
+
+    attribute :object, :string
+
+    attribute :name, :string
+    attribute :display_name, :string
+  end
+end

data/lib/nylas/http_client.rb

@@ -6,15 +6,18 @@ module Nylas
       402 => MessageRejected,
       403 => AccessDenied,
       404 => ResourceNotFound,
+      405 => MethodNotAllowed,
       422 => MailProviderError,
       429 => SendingQuotaExceeded,
       500 => InternalError,
+      501 => EndpointNotYetImplemented,
       502 => BadGateway,
       503 => ServiceUnavailable
     }.freeze
 
     include Logging
-    attr_accessor :api_server, :default_headers
+    attr_accessor :api_server, :service_domain
+    attr_writer :default_headers
     attr_reader :access_token
     attr_reader :app_id
     attr_reader :app_secret
@@ -25,7 +28,7 @@ module Nylas
     # @param api_server [String] (Optional) Which Nylas API Server to connect to. Only change this if
     #                            you're using a self-hosted Nylas instance.
     # @param service_domain [String] (Optional) Host you are authenticating OAuth against.
-    # @return [Nylas::API]
+    # @return [Nylas::HttpClient]
     def initialize(app_id:, app_secret:, access_token: nil, api_server: "https://api.nylas.com",
                    service_domain: "api.nylas.com")
       unless api_server.include?("://")
@@ -38,10 +41,14 @@ module Nylas
       @service_domain = service_domain
     end
 
+    # @return [Nylas::HttpClient[]
+    def as(access_token)
+      HttpClient.new(app_id: app_id, access_token: access_token,
+                     app_secret: app_secret, api_server: api_server, service_domain: service_domain)
+    end
+
     # Sends a request to the Nylas API and rai
     # @param method [Symbol] HTTP method for the API call. Either :get, :post, :delete, or :patch
-    # @param url [String] (Optional, defaults to nil) - Full URL to access. Deprecated and will be removed in
-    #                     5.0.
     # @param path [String] (Optional, defaults to nil) - Relative path from the API Base. Preferred way to
     #                      execute arbitrary or-not-yet-SDK-ified API commands.
     # @param headers [Hash] (Optional, defaults to {}) - Additional HTTP headers to include in the payload.
@@ -49,45 +56,47 @@ module Nylas
     #                      section of the URI fragment
     # @param payload [String,Hash] (Optional, defaults to nil) - Body to send with the request.
     # @return [Array Hash Stringn]
-    # rubocop:disable Metrics/ParameterLists
-    def execute(method:, url: nil, path: nil, headers: {}, query: {}, payload: nil)
-      headers[:params] = query
-      url ||= url_for_path(path)
-      resulting_headers = default_headers.merge(headers)
-      rest_client_execute(method: method, url: url, payload: payload,
-                          headers: resulting_headers) do |response, _request, result|
-
+    def execute(method:, path: nil, headers: {}, query: {}, payload: nil)
+      request = build_request(method: method, path: path, headers: headers, query: query, payload: payload)
+      rest_client_execute(**request) do |response, _request, result|
         response = parse_response(response)
         handle_failed_response(result: result, response: response)
         response
       end
     end
-    # rubocop:enable Metrics/ParameterLists
     inform_on :execute, level: :debug,
-                        also_log: { result: true, values: %i(method url path headers query payload) }
+                        also_log: { result: true, values: %i[method url path headers query payload] }
+
+    def build_request(method:, path: nil, headers: {}, query: {}, payload: nil)
+      headers[:params] = query
+      url ||= url_for_path(path)
+      resulting_headers = default_headers.merge(headers)
+      { method: method, url: url, payload: payload, headers: resulting_headers }
+    end
+    # rubocop:enable Metrics/ParameterLists
 
     # Syntactical sugar for making GET requests via the API.
     # @see #execute
-    def get(path: nil, url: nil, headers: {}, query: {})
-      execute(method: :get, path: path, query: query, url: url, headers: headers)
+    def get(path: nil, headers: {}, query: {})
+      execute(method: :get, path: path, query: query, headers: headers)
     end
 
     # Syntactical sugar for making POST requests via the API.
     # @see #execute
-    def post(path: nil, url: nil, payload: nil, headers: {}, query: {})
-      execute(method: :post, path: path, url: url, headers: headers, query: query, payload: payload)
+    def post(path: nil, payload: nil, headers: {}, query: {})
+      execute(method: :post, path: path, headers: headers, query: query, payload: payload)
     end
 
     # Syntactical sugar for making PUT requests via the API.
     # @see #execute
-    def put(path: nil, url: nil, payload:, headers: {}, query: {})
-      execute(method: :put, path: path, url: url, headers: headers, query: query, payload: payload)
+    def put(path: nil, payload:, headers: {}, query: {})
+      execute(method: :put, path: path, headers: headers, query: query, payload: payload)
     end
 
     # Syntactical sugar for making DELETE requests via the API.
     # @see #execute
-    def delete(path: nil, url: nil, payload: nil, headers: {}, query: {})
-      execute(method: :delete, path: path, url: url, headers: headers, query: query, payload: payload)
+    def delete(path: nil, payload: nil, headers: {}, query: {})
+      execute(method: :delete, path: path, headers: headers, query: query, payload: payload)
     end
     # rubocop:enable Metrics/ParameterList
 
@@ -96,7 +105,7 @@ module Nylas
                                     headers: headers, &block)
     end
     inform_on :rest_client_execute, level: :debug,
-                                    also_log: { result: true, values: %i(method url headers payload) }
+                                    also_log: { result: true, values: %i[method url headers payload] }
 
     def default_headers
       @default_headers ||= {
@@ -106,16 +115,16 @@ module Nylas
       }
     end
 
-    private def parse_response(response)
+    def parse_response(response)
       response.is_a?(Enumerable) ? response : JSON.parse(response, symbolize_names: true)
     rescue JSON::ParserError
       response
     end
+    inform_on :parse_response, level: :debug, also_log: { result: true }
 
-    private def url_for_path(path)
-      raise NoAuthToken if @access_token.nil? && (!@app_secret.nil? || !@app_id.nil?)
-      protocol, domain = @api_server.split("//")
-      "#{protocol}//#{@access_token}:@#{domain}#{path}"
+    def url_for_path(path)
+      protocol, domain = api_server.split("//")
+      "#{protocol}//#{access_token}:@#{domain}#{path}"
     end
 
     private def handle_failed_response(result:, response:)
@@ -129,7 +138,7 @@ module Nylas
       return if http_code == 200
       return unless response.is_a?(Hash)
       exception = HTTP_CODE_TO_EXCEPTIONS.fetch(http_code, APIError)
-      raise exception.new(response["type"], response["message"], response.fetch("server_error", nil))
+      raise exception.new(response[:type], response[:message], response.fetch(:server_error, nil))
     end
   end
 end