nylas 4.0.0.rc2 → 4.0.0.rc3

data/lib/nylas/im_address.rb

@@ -6,9 +6,4 @@ module Nylas
     attribute :type, :string
     attribute :im_address, :string
   end
-
-  # Serializes, Deserializes between {IMAddress} objects and their JSON representation
-  class IMAddressType < Types::HashType
-    casts_to IMAddress
-  end
 end

data/lib/nylas/label.rb

@@ -0,0 +1,22 @@
+module Nylas
+  # Structure to represent the Label Schema
+  # @see https://docs.nylas.com/reference#labels
+  class Label
+    include Model
+    self.resources_path = "/labels"
+    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/message.rb

@@ -0,0 +1,45 @@
+module Nylas
+  # Ruby representatin of a Nylas Message object
+  # @see https://docs.nylas.com/reference#messages
+  class Message
+    include Model
+    self.raw_mime_type = "message/rfc822"
+    self.resources_path = "/messages"
+    allows_operations(showable: true, listable: true, filterable: true, searchable: true, updatable: true)
+
+    attribute :id, :string
+    attribute :object, :string
+    attribute :account_id, :string
+    attribute :thread_id, :string
+
+    attribute :headers, :message_headers
+
+    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
+    # This is only used when receiving a message received notification via a webhook
+    attribute :received_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 starred?
+      starred
+    end
+
+    def unread?
+      unread
+    end
+  end
+end

data/lib/nylas/message_headers.rb

@@ -0,0 +1,25 @@
+module Nylas
+  # Translates message headers into a Ruby object
+  # @see https://docs.nylas.com/reference#section-message-views
+  class MessageHeaders
+    include Model::Attributable
+    attribute :in_reply_to, :string
+    attribute :message_id, :string
+    has_n_of_attribute :references, :string
+  end
+
+  # Serializes, Deserializes between {MessageHeaders} objects and a Hash
+  class MessageHeadersType < Types::ModelType
+    def initialize
+      super(model: MessageHeaders)
+    end
+    RUBY_KEY_TO_JSON_KEY_MAP = {
+      in_reply_to: :"In-Reply-To",
+      message_id: :"Message-Id",
+      references: :References
+    }.freeze
+    def json_key_from_attribute_name(attribute_name)
+      RUBY_KEY_TO_JSON_KEY_MAP.fetch(attribute_name)
+    end
+  end
+end

data/lib/nylas/message_tracking.rb

@@ -0,0 +1,11 @@
+module Nylas
+  # Message tracking features
+  # @see https://docs.nylas.com/reference#message-tracking-overview
+  class MessageTracking
+    include Model::Attributable
+    attribute :links, :boolean
+    attribute :opens, :boolean
+    attribute :thread_replies, :boolean
+    attribute :payload, :string
+  end
+end

data/lib/nylas/model.rb

@@ -7,33 +7,51 @@ module Nylas
   module Model
     attr_accessor :api
 
+    def model_class
+      self.class
+    end
+
     def self.included(model)
       model.include(Attributable)
       model.extend(ClassMethods)
-      model.collectionable = true
-      model.searchable = true
-      model.read_only = false
+      model.extend(Forwardable)
+      model.def_delegators :model_class, :creatable?, :filterable?, :listable?, :searchable?, :showable?,
+                           :updatable?, :destroyable?
+      model.allows_operations
     end
 
     def save
-      raise_if_read_only
-      result = if id
-                 api.execute(method: :put, payload: attributes.serialize, path: resource_path)
+      result = if persisted?
+                 raise ModelNotUpdatableError, self unless updatable?
+                 execute(method: :put, payload: attributes.serialize, path: resource_path)
                else
-                 api.execute(method: :post, payload: attributes.serialize, path: resources_path)
+                 create
                end
       attributes.merge(result)
     end
 
+    def persisted?
+      !id.nil?
+    end
+
+    def execute(method:, payload: nil, path:)
+      api.execute(method: method, payload: payload, path: path)
+    end
+
+    def create
+      raise ModelNotCreatableError, self unless creatable?
+      execute(method: :post, payload: attributes.serialize, path: resources_path)
+    end
+
     def update(**data)
-      raise_if_read_only
+      raise ModelNotUpdatableError, model_class unless updatable?
       attributes.merge(**data)
-      api.execute(method: :put, payload: attributes.serialize(keys: data.keys), path: resource_path)
+      execute(method: :put, payload: attributes.serialize(keys: data.keys), path: resource_path)
       true
     end
 
     def reload
-      attributes.merge(api.execute(method: :get, path: resource_path))
+      attributes.merge(execute(method: :get, path: resource_path))
       true
     end
 
@@ -42,11 +60,12 @@ module Nylas
     end
 
     def resources_path
-      self.class.resources_path
+      self.class.resources_path(api: api)
     end
 
     def destroy
-      api.execute(method: :delete, path: resource_path)
+      raise ModelNotDestroyableError, self unless destroyable?
+      execute(method: :delete, path: resource_path)
     end
 
     # @return [String] JSON String of the model.
@@ -54,28 +73,60 @@ module Nylas
       JSON.dump(to_h)
     end
 
-    def raise_if_read_only
-      self.class.raise_if_read_only
-    end
-
     # Allows you to narrow in exactly what kind of model you're working with
     module ClassMethods
-      attr_accessor :resources_path, :searchable, :read_only, :collectionable
+      attr_accessor :raw_mime_type, :creatable, :showable, :filterable, :searchable, :listable, :updatable,
+                    :destroyable
+      attr_writer :resources_path
+
+      # rubocop:disable Metrics/ParameterLists
+      def allows_operations(creatable: false, showable: false, listable: false, filterable: false,
+                            searchable: false, updatable: false, destroyable: false)
+
+        self.creatable ||= creatable
+        self.showable ||= showable
+        self.listable ||= listable
+        self.filterable ||= filterable
+        self.searchable ||= searchable
+        self.updatable ||= updatable
+        self.destroyable ||= destroyable
+      end
 
-      def read_only?
-        read_only == true
+      # rubocop:enable Metrics/ParameterLists
+      def creatable?
+        creatable
       end
 
-      def raise_if_read_only
-        raise NotImplementedError, "#{self} is read only" if read_only?
+      def showable?
+        showable
+      end
+
+      def listable?
+        listable
+      end
+
+      def filterable?
+        filterable
       end
 
       def searchable?
-        searchable == true
+        searchable
+      end
+
+      def updatable?
+        updatable
+      end
+
+      def destroyable?
+        destroyable
+      end
+
+      def resources_path(*)
+        @resources_path
       end
 
-      def collectionable?
-        collectionable == true
+      def exposable_as_raw?
+        !raw_mime_type.nil?
       end
 
       def from_json(json, api:)

data/lib/nylas/model/attributable.rb

@@ -23,14 +23,14 @@ module Nylas
 
       # Methods to call when tweaking Attributable classes
       module ClassMethods
-        # rubocop:disable Style/PredicateName
+        # rubocop:disable Naming/PredicateName
         def has_n_of_attribute(name, type_name, exclude_when: [], default: [])
           attribute_definitions[name] = ListAttributeDefinition.new(type_name: type_name,
                                                                     exclude_when: exclude_when,
                                                                     default: default)
           define_accessors(name)
         end
-        # rubocop:enable Style/PredicateName
+        # rubocop:enable Naming/PredicateName
 
         def attribute(name, type_name, exclude_when: [], default: nil)
           attribute_definitions[name] = AttributeDefinition.new(type_name: type_name,

data/lib/nylas/model/attributes.rb

@@ -19,6 +19,8 @@ module Nylas
 
       private def cast(key, value)
         attribute_definitions[key].cast(value)
+      rescue TypeError => e
+        raise TypeError, "#{key} #{e.message}"
       end
 
       # Merges data into the registry while casting input types correctly
@@ -31,7 +33,7 @@ module Nylas
       def to_h(keys: attribute_definitions.keys)
         keys.each_with_object({}) do |key, casted_data|
           value = attribute_definitions[key].serialize(self[key])
-          casted_data[key] = value unless value.nil? || value.empty?
+          casted_data[key] = value unless value.nil? || (value.respond_to?(:empty?) && value.empty?)
         end
       end
 

data/lib/nylas/native_authentication.rb

@@ -0,0 +1,31 @@
+module Nylas
+  # Authenticate your application using the native interface
+  # @see https://docs.nylas.com/reference#native-authentication-1
+  class NativeAuthentication
+    attr_accessor :api
+    def initialize(api:)
+      self.api = api
+    end
+
+    def authenticate(name:, email_address:, provider:, settings:, reauth_account_id: nil)
+      code = retrieve_code(name: name, email_address: email_address, provider: provider,
+                           settings: settings, reauth_account_id: reauth_account_id)
+
+      exchange_code_for_access_token(code)
+    end
+
+    private def retrieve_code(name:, email_address:, provider:, settings:, reauth_account_id:)
+      payload = { client_id: api.client.app_id, name: name, email_address: email_address,
+                  provider: provider, settings: settings }
+      payload[:reauth_account_id] = reauth_account_id
+      response = api.execute(method: :post, path: "/connect/authorize", payload: JSON.dump(payload))
+      response[:code]
+    end
+
+    private def exchange_code_for_access_token(code)
+      payload = { client_id: api.client.app_id, client_secret: api.client.app_secret, code: code }
+      response = api.execute(method: :post, path: "/connect/token", payload: JSON.dump(payload))
+      response[:access_token]
+    end
+  end
+end

data/lib/nylas/new_message.rb

@@ -0,0 +1,29 @@
+module Nylas
+  # Data structure for seending a message via the Nylas API
+  class NewMessage
+    include Model
+    self.creatable = false
+    self.showable = false
+    self.listable = false
+    self.filterable = false
+    self.updatable = false
+    self.destroyable = false
+
+    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
+
+    attribute :subject, :string
+    attribute :body, :string
+    attribute :reply_to_message_id, :string
+
+    has_n_of_attribute :file_ids, :string
+
+    attribute :tracking, :message_tracking
+
+    def send!
+      Message.new(api.execute(method: :post, path: "/send", payload: to_json).merge(api: api))
+    end
+  end
+end

data/lib/nylas/nylas_date.rb

@@ -11,8 +11,11 @@ module Nylas
   end
 
   # Serializes, Deserializes between {NylasDate} objects and a {Hash}
-  class NylasDateType < Types::HashType
-    casts_to NylasDate
+  class NylasDateType < Types::ModelType
+    def initialize
+      super(model: NylasDate)
+    end
+
     def cast(value)
       value.is_a?(String) ? super({ object: "date", date: value }) : super
     end

data/lib/nylas/participant.rb

@@ -0,0 +1,10 @@
+module Nylas
+  # Structure to represent the Participant
+  class Participant
+    include Model::Attributable
+    attribute :name, :string
+    attribute :email, :string
+    attribute :comment, :string
+    attribute :status, :string
+  end
+end

data/lib/nylas/phone_number.rb

@@ -6,9 +6,4 @@ module Nylas
     attribute :type, :string
     attribute :number, :string
   end
-
-  # Serializes, Deserializes between {PhoneNumber} objects and a {Hash}
-  class PhoneNumberType < Types::HashType
-    casts_to PhoneNumber
-  end
 end

data/lib/nylas/physical_address.rb

@@ -11,9 +11,4 @@ module Nylas
     attribute :city, :string
     attribute :country, :string
   end
-
-  # Serializes, Deserializes between {PhysicalAddress} objects and a {Hash}
-  class PhysicalAddressType < Types::HashType
-    casts_to PhysicalAddress
-  end
 end

data/lib/nylas/raw_message.rb

@@ -0,0 +1,15 @@
+module Nylas
+  # Allows sending of email with nylas from an rfc822 compatible string
+  class RawMessage
+    attr_accessor :api, :mime_compatible_string
+    def initialize(mime_compatible_string, api:)
+      self.api = api
+      self.mime_compatible_string = mime_compatible_string
+    end
+
+    def send!
+      Message.new(api.execute(method: :post, path: "/send", payload: mime_compatible_string,
+                              headers: { "Content-type" => "message/rfc822" }).merge(api: api))
+    end
+  end
+end

data/lib/nylas/recurrence.rb

@@ -0,0 +1,9 @@
+module Nylas
+  # Representation of a Recurrence object
+  # @see https://docs.nylas.com/reference#section-recurrence
+  class Recurrence
+    include Model::Attributable
+    has_n_of_attribute :rrule, :string
+    attribute :timezone, :string
+  end
+end