nylas 4.0.0.rc2 → 4.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5fd4eb7f8982e3da95740a92b4ff5d1307d22bc7
-  data.tar.gz: 3806c9465a159c517fc71165570a0c787751f79f
+SHA256:
+  metadata.gz: fac446793677a8c9ae9f69d5d70e1ef43cb5a452e600f590665afa2f6d82f0de
+  data.tar.gz: d42bf8cf84bf85be8e4a3b6bf896492da0e3e6795f6eb5afb538d6cdc55cad78
 SHA512:
-  metadata.gz: a1841957b48b50212c6026428401306cadf9c83fddb109e5567c0cb5bb5aa187e2a6383c804b546ffe1082d7bca395e73a2f63f035d20ab42a516fd44e831474
-  data.tar.gz: a21d29a3a95331f855b5f4a312183fea5da5dcf73de7546df452d4723b080838bdc26fe376eec1455b98b108e3d92c0e8a2ec6742e05efaa1e80d72f5ff89d61
+  metadata.gz: 7fe7bdd1b56c7fb1e37ce318c28ed419bf38124e052c8a5a5de61c609d1132cdeff7a728126d549e3e0da0388303585e63701fdc37f01cab6b0c773d7587729c
+  data.tar.gz: 33d014b9b2cbc74fc1d52a5b203017d9272952baa207ada25e89aef029051539f4d1f9066b72a055e319783b13dee6bb4a5f0130c69f9de1a675de0b1bc0e11a

data/lib/nylas.rb

@@ -17,15 +17,42 @@ require_relative "nylas/model"
 
 # Attribute types supported by the API
 require_relative "nylas/email_address"
+require_relative "nylas/event"
+require_relative "nylas/event_collection"
+require_relative "nylas/file"
+require_relative "nylas/folder"
 require_relative "nylas/im_address"
+require_relative "nylas/label"
+require_relative "nylas/message_headers"
+require_relative "nylas/message_tracking"
+require_relative "nylas/participant"
 require_relative "nylas/physical_address"
 require_relative "nylas/phone_number"
+require_relative "nylas/recurrence"
+require_relative "nylas/rsvp"
+require_relative "nylas/timespan"
 require_relative "nylas/web_page"
 require_relative "nylas/nylas_date"
 
+# Custom collection types
+require_relative "nylas/search_collection"
+require_relative "nylas/deltas_collection"
+
 # Models supported by the API
+require_relative "nylas/account"
+require_relative "nylas/calendar"
 require_relative "nylas/contact"
 require_relative "nylas/current_account"
+require_relative "nylas/deltas"
+require_relative "nylas/delta"
+require_relative "nylas/draft"
+require_relative "nylas/message"
+require_relative "nylas/new_message"
+require_relative "nylas/raw_message"
+require_relative "nylas/thread"
+require_relative "nylas/webhook"
+
+require_relative "nylas/native_authentication"
 
 require_relative "nylas/http_client"
 require_relative "nylas/api"
@@ -33,10 +60,26 @@ require_relative "nylas/api"
 # an SDK for interacting with the Nylas API
 # @see https://docs.nylas.com/reference
 module Nylas
-  Types.registry[:email_address] = EmailAddressType.new
-  Types.registry[:im_address] = IMAddressType.new
-  Types.registry[:physical_address] = PhysicalAddressType.new
-  Types.registry[:phone_number] = PhoneNumberType.new
-  Types.registry[:web_page] = WebPageType.new
+  Types.registry[:account] = Types::ModelType.new(model: Account)
+  Types.registry[:calendar] = Types::ModelType.new(model: Calendar)
+  Types.registry[:contact] = Types::ModelType.new(model: Contact)
+  Types.registry[:delta] = DeltaType.new
+  Types.registry[:draft] = Types::ModelType.new(model: Draft)
+  Types.registry[:email_address] = Types::ModelType.new(model: EmailAddress)
+  Types.registry[:event] = Types::ModelType.new(model: Event)
+  Types.registry[:file] = Types::ModelType.new(model: File)
+  Types.registry[:folder] = Types::ModelType.new(model: Folder)
+  Types.registry[:im_address] = Types::ModelType.new(model: IMAddress)
+  Types.registry[:label] = Types::ModelType.new(model: Label)
+  Types.registry[:message] = Types::ModelType.new(model: Message)
+  Types.registry[:message_headers] = MessageHeadersType.new
+  Types.registry[:message_tracking] = Types::ModelType.new(model: MessageTracking)
+  Types.registry[:participant] = Types::ModelType.new(model: Participant)
+  Types.registry[:physical_address] = Types::ModelType.new(model: PhysicalAddress)
+  Types.registry[:phone_number] = Types::ModelType.new(model: PhoneNumber)
+  Types.registry[:recurrence] = Types::ModelType.new(model: Recurrence)
+  Types.registry[:thread] = Types::ModelType.new(model: Thread)
+  Types.registry[:timespan] = Types::ModelType.new(model: Timespan)
+  Types.registry[:web_page] = Types::ModelType.new(model: WebPage)
   Types.registry[:nylas_date] = NylasDateType.new
 end

data/lib/nylas/account.rb

@@ -0,0 +1,31 @@
+module Nylas
+  # Representation of the accounts for Account management purposes.
+  # @see https://docs.nylas.com/reference#account-management
+  class Account
+    include Model
+    self.listable = true
+    self.showable = true
+
+    attribute :id, :string
+    attribute :account_id, :string
+    attribute :billing_state, :string
+    attribute :sync_state, :string
+
+    attribute :email, :string
+    attribute :trial, :boolean
+
+    def upgrade
+      response = execute(method: :post, path: "#{resource_path}/upgrade")
+      response[:success]
+    end
+
+    def downgrade
+      response = execute(method: :post, path: "#{resource_path}/downgrade")
+      response[:success]
+    end
+
+    def self.resources_path(api:)
+      "/a/#{api.app_id}/accounts"
+    end
+  end
+end

data/lib/nylas/api.rb

@@ -3,7 +3,7 @@ module Nylas
   class API
     attr_accessor :client
     extend Forwardable
-    def_delegators :client, :execute, :get, :post, :put, :delete
+    def_delegators :client, :execute, :get, :post, :put, :delete, :app_id
 
     include Logging
 
@@ -24,6 +24,13 @@ module Nylas
     end
     # rubocop:enable Metrics/ParameterLists
 
+    # @return [String] A Nylas access token for that particular user.
+    def authenticate(name:, email_address:, provider:, settings:, reauth_account_id: nil)
+      NativeAuthentication.new(api: self).authenticate(name: name, email_address: email_address,
+                                                       provider: provider, settings: settings,
+                                                       reauth_account_id: reauth_account_id)
+    end
+
     # @return [Collection<Contact>] A queryable collection of Contacts
     def contacts
       @contacts ||= Collection.new(model: Contact, api: self)
@@ -32,7 +39,84 @@ module Nylas
     # @return [CurrentAccount] The account details for whomevers access token is set
     def current_account
       prevent_calling_if_missing_access_token(:current_account)
-      CurrentAccount.from_hash(client.execute(method: :get, path: "/account"), api: self)
+      CurrentAccount.from_hash(execute(method: :get, path: "/account"), api: self)
+    end
+
+    # @return [Collection<Account>] A queryable collection of {Account}s
+    def accounts
+      @accounts ||= Collection.new(model: Account, api: as(client.app_secret))
+    end
+
+    # @return [Collection<Calendar>] A queryable collection of {Calendar}s
+    def calendars
+      @calendars ||= Collection.new(model: Calendar, api: self)
+    end
+
+    # @return [DeltasCollection<Delta>] A queryable collection of Deltas, which are themselves a collection.
+    def deltas
+      @deltas ||= DeltasCollection.new(api: self)
+    end
+
+    # @return[Collection<Draft>] A queryable collection of {Draft} objects
+    def drafts
+      @drafts ||= Collection.new(model: Draft, api: self)
+    end
+
+    # @return [Collection<Event>] A queryable collection of {Event}s
+    def events
+      @events ||= EventCollection.new(model: Event, api: self)
+    end
+
+    # @return [Collection<Folder>] A queryable collection of {Folder}s
+    def folders
+      @folders ||= Collection.new(model: Folder, api: self)
+    end
+
+    # @return [Collection<File>] A queryable collection of {File}s
+    def files
+      @files ||= Collection.new(model: File, api: self)
+    end
+
+    # @return [Collection<Label>] A queryable collection of {Label} objects
+    def labels
+      @labels ||= Collection.new(model: Label, api: self)
+    end
+
+    # @return[Collection<Message>] A queryable collection of {Message} objects
+    def messages
+      @messages ||= Collection.new(model: Message, api: self)
+    end
+
+    # Revokes access to the Nylas API for the given access token
+    # @return [Boolean]
+    def revoke(access_token)
+      response = client.as(access_token).post(path: "/oauth/revoke")
+      response.code == 200 && response.empty?
+    end
+
+    # @param message [Hash, String, #send!]
+    # @return [Message] The resulting message
+    def send!(message)
+      return message.send! if message.respond_to?(:send!)
+      return NewMessage.new(**message.merge(api: self)).send! if message.respond_to?(:key?)
+      return RawMessage.new(message, api: self).send! if message.is_a? String
+    end
+
+    # Allows you to get an API that acts as a different user but otherwise has the same settings
+    # @param [String] Oauth Access token or app secret used to authenticate with the API
+    # @return [API]
+    def as(access_token)
+      API.new(client: client.as(access_token))
+    end
+
+    # @return [Collection<Thread>] A queryable collection of Threads
+    def threads
+      @threads ||= Collection.new(model: Thread, api: self)
+    end
+
+    # @return [Collection<Webhook>] A queryable collection of {Webhook}s
+    def webhooks
+      @webhooks ||= Collection.new(model: Webhook, api: as(client.app_secret))
     end
 
     private def prevent_calling_if_missing_access_token(method_name)

data/lib/nylas/calendar.rb

@@ -0,0 +1,27 @@
+module Nylas
+  # Ruby bindings for the Nylas Calendar API
+  # @see https://docs.nylas.com/reference#calendars
+  class Calendar
+    include Model
+    self.resources_path = "/calendars"
+    allows_operations(listable: true, filterable: true, showable: true)
+
+    attribute :id, :string
+    attribute :account_id, :string
+
+    attribute :object, :string
+
+    attribute :name, :string
+    attribute :description, :string
+
+    attribute :read_only, :boolean
+
+    def read_only?
+      read_only == true
+    end
+
+    def events
+      api.events.where(calendar_id: id)
+    end
+  end
+end

data/lib/nylas/collection.rb

@@ -2,56 +2,70 @@ module Nylas
   # An enumerable for working with index and search endpoints
   class Collection
     attr_accessor :model, :api, :constraints
+    extend Forwardable
+    def_delegators :each, :map, :select, :reject, :to_a, :take
+    def_delegators :to_a, :first, :last, :[]
+
     def initialize(model:, api:, constraints: nil)
       self.constraints = Constraints.from_constraints(constraints)
       self.model = model
       self.api = api
     end
 
+    # Instantiates a new model
     def new(**attributes)
-      model.from_hash(attributes, api: api)
+      model.new(attributes.merge(api: api))
     end
 
     def create(**attributes)
-      model.raise_if_read_only
-      instance = model.from_hash(attributes, api: api)
+      instance = model.new(attributes.merge(api: api))
       instance.save
       instance
     end
 
+    # Merges in additional filters when querying the collection
+    # @return [Collection<Model>]
     def where(filters)
-      raise NotImplementedError, "#{model} does not support search" unless model.searchable?
+      raise ModelNotFilterableError, model unless model.filterable?
       self.class.new(model: model, api: api, constraints: constraints.merge(where: filters))
     end
 
+    def search(query)
+      raise ModelNotSearchableError, model unless model.searchable?
+      SearchCollection.new(model: model, api: api, constraints: constraints.merge(where: { q: query }))
+    end
+
+    # The collection now returns a string representation of the model in a particular mime type instead of
+    # Model objects
+    # @return [Collection<String>]
+    def raw
+      raise ModelNotAvailableAsRawError, model unless model.exposable_as_raw?
+      self.class.new(model: model, api: api, constraints: constraints.merge(accept: model.raw_mime_type))
+    end
+
+    # @return [Integer]
     def count
       self.class.new(model: model, api: api, constraints: constraints.merge(view: "count")).execute[:count]
     end
 
-    def first
-      model.from_hash(execute.first, api: api)
+    # @return [Collection<Model>]
+    def expanded
+      self.class.new(model: model, api: api, constraints: constraints.merge(view: "expanded"))
     end
 
-    def[](index)
-      model.from_hash(execute(index), api: api)
+    # @return [Array<String>]
+    def ids
+      self.class.new(model: model, api: api, constraints: constraints.merge(view: "ids")).execute
     end
 
     # Iterates over a single page of results based upon current pagination settings
     def each
       return enum_for(:each) unless block_given?
       execute.each do |result|
-        yield(model.from_hash(result, api: api))
+        yield(model.new(result.merge(api: api)))
       end
     end
 
-    def to_a
-      each.to_a
-    end
-
-    def map(&block)
-      each.map(&block)
-    end
-
     def limit(quantity)
       self.class.new(model: model, api: api, constraints: constraints.merge(limit: quantity))
     end
@@ -76,7 +90,7 @@ module Nylas
       end
     end
 
-    def next_page(accumulated: nil, current_page: nil)
+    def next_page(accumulated:, current_page:)
       return nil unless more_pages?(accumulated, current_page)
       self.class.new(model: model, api: api, constraints: constraints.next_page)
     end
@@ -91,6 +105,18 @@ module Nylas
     # Retrieves a record. Nylas doesn't support where filters on GET so this will not take into
     # consideration other query constraints, such as where clauses.
     def find(id)
+      constraints.accept == "application/json" ? find_model(id) : find_raw(id)
+    end
+
+    def find_raw(id)
+      api.execute(to_be_executed.merge(path: "#{resources_path}/#{id}")).to_s
+    end
+
+    def resources_path
+      model.resources_path(api: api)
+    end
+
+    def find_model(id)
       instance = model.from_hash({ id: id }, api: api)
       instance.reload
       instance
@@ -98,7 +124,8 @@ module Nylas
 
     # @return [Hash] Specification for request to be passed to {API#execute}
     def to_be_executed
-      { method: :get, path: model.resources_path, query: constraints.to_query }
+      { method: :get, path: resources_path, query: constraints.to_query,
+        headers: constraints.to_headers }
     end
 
     # Retrieves the data from the API for the particular constraints

data/lib/nylas/constraints.rb

@@ -1,22 +1,26 @@
 module Nylas
   # The constraints a particular GET request will include in their query params
   class Constraints
-    attr_accessor :where, :limit, :offset, :view, :per_page
-    def initialize(where: {}, limit: nil, offset: 0, view: nil, per_page: 100)
+    attr_accessor :where, :limit, :offset, :view, :per_page, :accept
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(where: {}, limit: nil, offset: 0, view: nil, per_page: 100, accept: "application/json")
       self.where = where
       self.limit = limit
       self.offset = offset
       self.view = view
       self.per_page = per_page
+      self.accept = accept
     end
 
-    def merge(where: {}, limit: nil, offset: nil, view: nil, per_page: nil)
+    def merge(where: {}, limit: nil, offset: nil, view: nil, per_page: nil, accept: nil)
       Constraints.new(where: where.merge(where),
                       limit: limit || self.limit,
                       per_page: per_page || self.per_page,
                       offset: offset || self.offset,
-                      view: view || self.view)
+                      view: view || self.view,
+                      accept: accept || self.accept)
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def next_page
       merge(offset: offset + per_page)
@@ -32,6 +36,10 @@ module Nylas
       query
     end
 
+    def to_headers
+      accept == "application/json" ? {} : { "Accept" => accept, "Content-types" => accept }
+    end
+
     def limit_for_query
       !limit.nil? && limit < per_page ? limit : per_page
     end

data/lib/nylas/contact.rb

@@ -4,12 +4,20 @@ module Nylas
   class Contact
     include Model
     self.resources_path = "/contacts"
+    self.creatable = true
+    self.listable = true
+    self.showable = true
+    self.filterable = true
+    self.updatable = true
+    self.destroyable = true
 
-    attribute :id, :string, exclude_when: %i(creating updating)
+    attribute :id, :string, exclude_when: %i[creating updating]
     attribute :object, :string, default: "contact"
-    attribute :account_id, :string, exclude_when: %i(creating updating)
+    attribute :account_id, :string, exclude_when: %i[creating updating]
+
     attribute :given_name, :string
     attribute :middle_name, :string
+    attribute :picture_url, :string
     attribute :surname, :string
     attribute :birthday, :nylas_date
     attribute :suffix, :string