nylas 4.6.7 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dd52077bca505902f8fe016a103318a1c426f74f01235a36c27a2463478f101
-  data.tar.gz: 91f2addf66e656561881e721402955080f6e040536c3168737f7b62a4b74a9dd
+  metadata.gz: 8ab5c418509c447497fbd6106eb6e01fb7c23af451bf8150584b9bcf4e1ce736
+  data.tar.gz: 6827492459317c848f6f89c748a1cf5f5858506b83a578f53dbb4169010779ad
 SHA512:
-  metadata.gz: ed82717d82cdc4b5fed03a09e7ee1553ba16071e4603b8cedce2518871fc44e2b34c8bd0ce5d9e077bb492a1d216de577264da104014c75e9964b44f7a238e52
-  data.tar.gz: be58aff204cad1ce196f8fbeb766708d407d135a8247c484292a5a16fd821119727d21ded457b2b80650b58fc9c70d2a07c38dfc4beea94dc143454bc9377136
+  metadata.gz: 593d58ed82147ee51b00f90ed0e619eb4a6680b07cc8bae04eeba0809026e2e24ecce2565292c026bd2d164fba8a6a76f67768bf362c35c8e50bc0efbbe61da1
+  data.tar.gz: 10ed94be5d4e2c785ef92d32495301857f6c193e85e5087e96e8c2826b379219833f6db07c669c38fb7be573f77376748a6b323c1af46952c10853bf50e04233

data/lib/nylas.rb

@@ -69,11 +69,25 @@ require_relative "nylas/deltas"
 require_relative "nylas/delta"
 require_relative "nylas/draft"
 require_relative "nylas/message"
+require_relative "nylas/room_resource"
 require_relative "nylas/new_message"
 require_relative "nylas/raw_message"
 require_relative "nylas/thread"
 require_relative "nylas/webhook"
 
+# Neural specific types
+require_relative "nylas/neural"
+require_relative "nylas/neural_sentiment_analysis"
+require_relative "nylas/neural_ocr"
+require_relative "nylas/neural_categorizer"
+require_relative "nylas/neural_clean_conversation"
+require_relative "nylas/neural_contact_link"
+require_relative "nylas/neural_contact_name"
+require_relative "nylas/neural_signature_contact"
+require_relative "nylas/neural_signature_extraction"
+require_relative "nylas/neural_message_options"
+require_relative "nylas/categorize"
+
 require_relative "nylas/native_authentication"
 
 require_relative "nylas/http_client"
@@ -94,6 +108,7 @@ module Nylas
   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[:room_resource] = Types::ModelType.new(model: RoomResource)
   Types.registry[:message] = Types::ModelType.new(model: Message)
   Types.registry[:message_headers] = MessageHeadersType.new
   Types.registry[:message_tracking] = Types::ModelType.new(model: MessageTracking)
@@ -108,4 +123,9 @@ module Nylas
   Types.registry[:contact_group] = Types::ModelType.new(model: ContactGroup)
   Types.registry[:when] = Types::ModelType.new(model: When)
   Types.registry[:time_slot] = Types::ModelType.new(model: TimeSlot)
+  Types.registry[:neural] = Types::ModelType.new(model: Neural)
+  Types.registry[:categorize] = Types::ModelType.new(model: Categorize)
+  Types.registry[:neural_signature_contact] = Types::ModelType.new(model: NeuralSignatureContact)
+  Types.registry[:neural_contact_link] = Types::ModelType.new(model: NeuralContactLink)
+  Types.registry[:neural_contact_name] = Types::ModelType.new(model: NeuralContactName)
 end

data/lib/nylas/api.rb

@@ -6,7 +6,7 @@ module Nylas
     attr_accessor :client
 
     extend Forwardable
-    def_delegators :client, :execute, :get, :post, :put, :delete, :app_id
+    def_delegators :client, :execute, :get, :post, :put, :delete, :app_id, :api_server
 
     include Logging
 
@@ -16,13 +16,11 @@ module Nylas
     # @param access_token [String] (Optional) Your users access token.
     # @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]
     def initialize(client: nil, app_id: nil, app_secret: nil, access_token: nil,
-                   api_server: "https://api.nylas.com", service_domain: "api.nylas.com")
+                   api_server: "https://api.nylas.com")
       self.client = client || HttpClient.new(app_id: app_id, app_secret: app_secret,
-                                             access_token: access_token, api_server: api_server,
-                                             service_domain: service_domain)
+                                             access_token: access_token, api_server: api_server)
     end
 
     # @return [String] A Nylas access token for that particular user.
@@ -37,6 +35,19 @@ module Nylas
       )
     end
 
+    def authentication_url(redirect_uri:, scopes:, response_type: "code", login_hint: nil, state: nil)
+      params = {
+        client_id: app_id,
+        redirect_uri: redirect_uri,
+        response_type: response_type,
+        login_hint: login_hint
+      }
+      params[:state] = state if state
+      params[:scopes] = scopes.join(",") if scopes
+
+      "#{api_server}/oauth/authorize?#{URI.encode_www_form(params)}"
+    end
+
     def exchange_code_for_token(code)
       data = {
         "client_id" => app_id,
@@ -110,6 +121,16 @@ module Nylas
       @messages ||= Collection.new(model: Message, api: self)
     end
 
+    # @return[Collection<RoomResource>] A queryable collection of {RoomResource} objects
+    def room_resources
+      @room_resources ||= Collection.new(model: RoomResource, api: self)
+    end
+
+    # @return[Neural] A {Neural} object that provides
+    def neural
+      @neural ||= Neural.new(api: self)
+    end
+
     # Revokes access to the Nylas API for the given access token
     # @return [Boolean]
     def revoke(access_token)

data/lib/nylas/categorize.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent the Neural Categorize object.
+  # @see https://developer.nylas.com/docs/intelligence/categorizer/#categorize-message-response
+  class Categorize
+    include Model::Attributable
+
+    attribute :category, :string
+    attribute :categorized_at, :unix_timestamp
+    attribute :model_version, :string
+    has_n_of_attribute :subcategories, :string
+  end
+end

data/lib/nylas/collection.rb

@@ -130,7 +130,7 @@ module Nylas
       response = api.execute(
         **to_be_executed.merge(
           path: "#{resources_path}/#{id}",
-          query: {}
+          query: view_query
         )
       )
       model.from_hash(response, api: api)
@@ -147,5 +147,15 @@ module Nylas
     def execute
       api.execute(**to_be_executed)
     end
+
+    private
+
+    def view_query
+      if constraints.view
+        { view: constraints.view }
+      else
+        {}
+      end
+    end
   end
 end

data/lib/nylas/contact.rb

@@ -13,9 +13,9 @@ module Nylas
     self.updatable = true
     self.destroyable = true
 
-    attribute :id, :string, exclude_when: %i[creating updating]
+    attribute :id, :string, read_only: true
     attribute :object, :string, default: "contact"
-    attribute :account_id, :string, exclude_when: %i[creating updating]
+    attribute :account_id, :string, read_only: true
 
     attribute :given_name, :string
     attribute :middle_name, :string

data/lib/nylas/delta.rb

@@ -6,6 +6,7 @@ module Nylas
   # @see https://docs.nylas.com/reference#deltas
   class Delta
     include Model::Attributable
+
     attribute :id, :string
     attribute :type, :string
     attribute :object, :string
@@ -14,6 +15,8 @@ module Nylas
     attribute :namespace_id, :string
     attribute :account_id, :string
 
+    attribute :headers, :message_headers
+
     attribute :date, :unix_timestamp
     attribute :metadata, :hash
     attribute :object_attributes, :hash
@@ -24,6 +27,8 @@ module Nylas
       @model ||= Types.registry[object.to_sym].cast(object_attributes_with_ids)
     end
 
+    private
+
     def object_attributes_with_ids
       (object_attributes || {}).merge(id: id, account_id: account_id)
     end
@@ -42,8 +47,10 @@ module Nylas
              else
                data
              end
+
+      data = data.merge(data[:attributes]) if data[:attributes]
       data[:object_attributes] = data.delete(:attributes)
-      super(data)
+      super(**data)
     end
   end
 end

data/lib/nylas/deltas.rb

@@ -14,6 +14,6 @@ module Nylas
     attribute :cursor_end, :string
 
     extend Forwardable
-    def_delegators :deltas, :count, :length, :each, :map, :first, :to_a, :empty?
+    def_delegators :deltas, :count, :length, :each, :map, :first, :last, :to_a, :empty?
   end
 end

data/lib/nylas/draft.rb

@@ -29,7 +29,8 @@ module Nylas
     attribute :unread, :boolean
 
     has_n_of_attribute :events, :event
-    has_n_of_attribute :files, :file
+    has_n_of_attribute :files, :file, read_only: true
+    has_n_of_attribute :file_ids, :string
     attribute :folder, :folder
     has_n_of_attribute :labels, :label
 
@@ -37,6 +38,20 @@ module Nylas
 
     transfer :api, to: %i[events files folder labels]
 
+    def update(**data)
+      self.files = data[:files] if data[:files]
+      extract_file_ids!
+      data[:file_ids] = file_ids
+
+      super
+    end
+
+    def create
+      extract_file_ids!
+
+      super
+    end
+
     def send!
       return execute(method: :post, path: "/send", payload: to_json) if tracking
 
@@ -53,7 +68,21 @@ module Nylas
     end
 
     def destroy
-      execute(method: :delete, path: resource_path, payload: attributes.serialize(keys: [:version]))
+      execute(method: :delete, path: resource_path, payload: attributes.serialize_for_api(keys: [:version]))
+    end
+
+    private
+
+    def save_call
+      extract_file_ids!
+
+      super
+    end
+
+    def extract_file_ids!
+      files = self.files || []
+
+      self.file_ids = files.map(&:id)
     end
   end
 end

data/lib/nylas/event.rb

@@ -9,9 +9,9 @@ module Nylas
     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 :id, :string, read_only: true
+    attribute :object, :string, read_only: true
+    attribute :account_id, :string, read_only: true
     attribute :calendar_id, :string
     attribute :master_event_id, :string
     attribute :message_id, :string
@@ -27,6 +27,7 @@ module Nylas
     attribute :status, :string
     attribute :title, :string
     attribute :when, :when
+    attribute :metadata, :hash
     attribute :original_start_time, :unix_timestamp
 
     attr_accessor :notify_participants

data/lib/nylas/http_client.rb

@@ -5,6 +5,8 @@ module Nylas
 
   # Plain HTTP client that can be used to interact with the Nylas API sans any type casting.
   class HttpClient # rubocop:disable Metrics/ClassLength
+    HTTP_SUCCESS_CODES = [200, 201, 302].freeze
+
     HTTP_CODE_TO_EXCEPTIONS = {
       400 => InvalidRequest,
       401 => UnauthorizedRequest,
@@ -31,9 +33,10 @@ module Nylas
       "/delta/longpoll" => 3650,
       "/delta/streaming" => 3650
     }.freeze
+    SUPPORTED_API_VERSION = "2.2"
 
     include Logging
-    attr_accessor :api_server, :service_domain
+    attr_accessor :api_server
     attr_writer :default_headers
     attr_reader :access_token
     attr_reader :app_id
@@ -44,10 +47,8 @@ module Nylas
     # @param access_token [String] (Optional) Your users access token.
     # @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::HttpClient]
-    def initialize(app_id:, app_secret:, access_token: nil, api_server: "https://api.nylas.com",
-                   service_domain: "api.nylas.com")
+    def initialize(app_id:, app_secret:, access_token: nil, api_server: "https://api.nylas.com")
       unless api_server.include?("://")
         raise "When overriding the Nylas API server address, you must include https://"
       end
@@ -56,13 +57,12 @@ module Nylas
       @access_token = access_token
       @app_secret = app_secret
       @app_id = app_id
-      @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)
+                     app_secret: app_secret, api_server: api_server)
     end
 
     # Sends a request to the Nylas API and rai
@@ -92,7 +92,12 @@ module Nylas
           content_type = response.headers[:content_type].downcase
         end
 
-        response = parse_response(response) if content_type == "application/json"
+        begin
+          response = parse_response(response) if content_type == "application/json"
+        rescue Nylas::JsonParseError
+          handle_failed_response(result: result, response: response)
+          raise
+        end
 
         handle_failed_response(result: result, response: response)
         response
@@ -103,8 +108,8 @@ module Nylas
                         also_log: { result: true, values: %i[method url path headers query payload] }
 
     def build_request(method:, path: nil, headers: {}, query: {}, payload: nil, timeout: nil)
-      headers[:params] = query
       url ||= url_for_path(path)
+      url = add_query_params_to_url(url, query)
       resulting_headers = default_headers.merge(headers)
       { method: method, url: url, payload: payload, headers: resulting_headers, timeout: timeout }
     end
@@ -137,8 +142,9 @@ module Nylas
       @default_headers ||= {
         "X-Nylas-API-Wrapper" => "ruby",
         "X-Nylas-Client-Id" => @app_id,
+        "Nylas-API-Version" => SUPPORTED_API_VERSION,
         "User-Agent" => "Nylas Ruby SDK #{Nylas::VERSION} - #{RUBY_VERSION}",
-        "Content-types" => "application/json"
+        "Content-type" => "application/json"
       }
     end
 
@@ -175,11 +181,40 @@ module Nylas
     end
 
     def handle_anticipated_failure_mode(http_code:, response:)
-      return if http_code == 200
-      return unless response.is_a?(Hash)
+      return if HTTP_SUCCESS_CODES.include?(http_code)
 
       exception = HTTP_CODE_TO_EXCEPTIONS.fetch(http_code, APIError)
-      raise exception.new(response[:type], response[:message], response.fetch(:server_error, nil))
+      raise exception.new(http_code, response) unless response.is_a?(Hash)
+
+      raise exception.new(
+        response[:type],
+        response[:message],
+        response.fetch(:server_error, nil)
+      )
+    end
+
+    def add_query_params_to_url(url, query)
+      unless query.empty?
+        uri = URI.parse(url)
+        query = custom_params(query)
+        params = URI.decode_www_form(uri.query || "") + query.to_a
+        uri.query = URI.encode_www_form(params)
+        url = uri.to_s
+      end
+
+      url
+    end
+
+    def custom_params(query)
+      # Convert hash to "<key>:<value>" form for metadata_pair query
+      if query.key?(:metadata_pair)
+        pairs = query[:metadata_pair].map do |key, value|
+          "#{key}:#{value}"
+        end
+        query[:metadata_pair] = pairs
+      end
+
+      query
     end
   end
 end

data/lib/nylas/message.rb

@@ -37,7 +37,7 @@ module Nylas
     attribute :folder, :folder
     attribute :folder_id, :string
 
-    has_n_of_attribute :labels, :label, exclude_when: [:saving]
+    has_n_of_attribute :labels, :label, read_only: true
     has_n_of_attribute :label_ids, :string
 
     transfer :api, to: %i[events files folder labels]
@@ -67,6 +67,8 @@ module Nylas
       return self unless headers.nil?
 
       assign(**api.execute(method: :get, path: resource_path, query: { view: "expanded" }))
+      # Transfer reference to the API to attributes that need it
+      transfer_attributes
       self
     end
 
@@ -75,7 +77,7 @@ module Nylas
 
       execute(
         method: :put,
-        payload: attributes.serialize(keys: allowed_keys_for_save),
+        payload: attributes.serialize_for_api,
         path: resource_path
       )
     end

data/lib/nylas/model.rb

@@ -48,7 +48,7 @@ module Nylas
 
       execute(
         method: :post,
-        payload: attributes.serialize,
+        payload: attributes.serialize_for_api,
         path: resources_path,
         query: query_params
       )
@@ -58,12 +58,37 @@ module Nylas
       raise ModelNotUpdatableError, model_class unless updatable?
 
       attributes.merge(**data)
-      execute(
-        method: :put,
-        payload: attributes.serialize(keys: data.keys),
-        path: resource_path,
-        query: query_params
-      )
+      payload = attributes.serialize_for_api(keys: data.keys)
+      update_call(payload)
+
+      true
+    rescue Registry::MissingKeyError => e
+      raise ModelMissingFieldError.new(e.key, self)
+    end
+
+    def save_all_attributes
+      result = if persisted?
+                 raise ModelNotUpdatableError, self unless updatable?
+
+                 execute(
+                   method: :put,
+                   payload: attributes.serialize_all_for_api,
+                   path: resource_path
+                 )
+               else
+                 create
+               end
+
+      attributes.merge(result)
+    end
+
+    def update_all_attributes(**data)
+      raise ModelNotUpdatableError, model_class unless updatable?
+
+      attributes.merge(**data)
+      payload = attributes.serialize_all_for_api(keys: data.keys)
+      update_call(payload)
+
       true
     rescue Registry::MissingKeyError => e
       raise ModelMissingFieldError.new(e.key, self)
@@ -95,20 +120,24 @@ module Nylas
 
     private
 
-    def allowed_keys_for_save
-      attributes.attribute_definitions.to_h.reject do |_k, v|
-        v.exclude_when.include?(:saving)
-      end.keys
-    end
-
     def save_call
       execute(
         method: :put,
-        payload: attributes.serialize(keys: allowed_keys_for_save),
+        payload: attributes.serialize_for_api,
         path: resource_path
       )
     end
 
+    def update_call(payload)
+      result = execute(
+        method: :put,
+        payload: payload,
+        path: resource_path,
+        query: query_params
+      )
+      attributes.merge(result) if result
+    end
+
     def query_params
       {}
     end

data/lib/nylas/model/attributable.rb

@@ -34,17 +34,22 @@ module Nylas
       # Methods to call when tweaking Attributable classes
       module ClassMethods
         # 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)
+        def has_n_of_attribute(name, type_name, read_only: false, default: [])
+          attribute_definitions[name] = ListAttributeDefinition.new(
+            type_name: type_name,
+            read_only: read_only,
+            default: default
+          )
           define_accessors(name)
         end
         # rubocop:enable Naming/PredicateName
 
-        def attribute(name, type_name, exclude_when: [], default: nil)
-          attribute_definitions[name] = AttributeDefinition.new(type_name: type_name,
-                                                                exclude_when: exclude_when, default: default)
+        def attribute(name, type_name, read_only: false, default: nil)
+          attribute_definitions[name] = AttributeDefinition.new(
+            type_name: type_name,
+            read_only: read_only,
+            default: default
+          )
           define_accessors(name)
         end
 
@@ -58,6 +63,21 @@ module Nylas
           end
         end
 
+        # Allows a class to inherit parent's attributes
+        def inherit_attributes
+          return if superclass.nil?
+
+          parent_attributes = superclass.attribute_definitions
+          parent_attributes.each do |parent_attribute|
+            name = parent_attribute[0]
+            attr = parent_attribute[1]
+            next if attribute_definitions.key?(name)
+
+            attribute_definitions[name] = attr
+            define_accessors(name)
+          end
+        end
+
         def attribute_definitions
           @attribute_definitions ||= Registry.new
         end

data/lib/nylas/model/attribute_definition.rb

@@ -6,11 +6,11 @@ module Nylas
     class AttributeDefinition
       extend Forwardable
       def_delegators :type, :cast, :serialize
-      attr_accessor :type_name, :exclude_when, :default
+      attr_accessor :type_name, :read_only, :default
 
-      def initialize(type_name:, exclude_when:, default:)
+      def initialize(type_name:, read_only:, default:)
         self.type_name = type_name
-        self.exclude_when = exclude_when
+        self.read_only = read_only
         self.default = default
       end
 

data/lib/nylas/model/attributes.rb

@@ -39,6 +39,22 @@ module Nylas
         JSON.dump(to_h(keys: keys))
       end
 
+      def serialize_for_api(keys: attribute_definitions.keys)
+        api_keys = keys.delete_if { |key| attribute_definitions[key].read_only == true }
+
+        serialize(keys: api_keys)
+      end
+
+      def serialize_all_for_api(keys: attribute_definitions.keys)
+        api_keys = keys.delete_if { |key| attribute_definitions[key].read_only == true }
+
+        JSON.dump(
+          api_keys.each_with_object({}) do |key, casted_data|
+            casted_data[key] = attribute_definitions[key].serialize(self[key])
+          end
+        )
+      end
+
       private
 
       def cast(key, value)

data/lib/nylas/model/list_attribute_definition.rb

@@ -4,11 +4,11 @@ module Nylas
   module Model
     # Allows models to have an attribute which is a lists of another type of thing
     class ListAttributeDefinition
-      attr_accessor :type_name, :exclude_when, :default
+      attr_accessor :type_name, :read_only, :default
 
-      def initialize(type_name:, exclude_when:, default:)
+      def initialize(type_name:, read_only:, default:)
         self.type_name = type_name
-        self.exclude_when = exclude_when
+        self.read_only = read_only
         self.default = default
       end
 

data/lib/nylas/neural.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Class containing methods for accessing Neural API features.
+  # @see https://developer.nylas.com/docs/intelligence/
+  class Neural
+    attr_accessor :api
+
+    def initialize(api:)
+      self.api = api
+    end
+
+    def sentiment_analysis_message(message_ids)
+      body = { message_id: message_ids }
+      response = request(NeuralSentimentAnalysis.resources_path, body)
+
+      collection = []
+      response.each do |sentiment|
+        collection.push(NeuralSentimentAnalysis.new(**sentiment.merge(api: api)))
+      end
+      collection
+    end
+
+    def sentiment_analysis_text(text)
+      body = { text: text }
+      NeuralSentimentAnalysis.new(**request(NeuralSentimentAnalysis.resources_path, body).merge(api: api))
+    end
+
+    def extract_signature(message_ids, options = nil)
+      body = { message_id: message_ids }
+      body = body.merge(options) unless options.nil?
+      response = request(NeuralSignatureExtraction.resources_path, body)
+
+      collection = []
+      response.each do |signature|
+        collection.push(NeuralSignatureExtraction.new(**signature.merge(api: api)))
+      end
+      collection
+    end
+
+    def ocr_request(file_id, pages = nil)
+      body = { file_id: file_id }
+      body[:pages] = pages unless pages.nil?
+
+      NeuralOcr.new(**request(NeuralOcr.resources_path, body).merge(api: api))
+    end
+
+    def categorize(message_ids)
+      body = { message_id: message_ids }
+      response = request(NeuralCategorizer.resources_path, body)
+
+      collection = []
+      response.each do |categorize|
+        collection.push(NeuralCategorizer.new(**categorize.merge(api: api)))
+      end
+      collection
+    end
+
+    def clean_conversation(message_ids, options = nil)
+      body = { message_id: message_ids }
+      body = body.merge(delete_from_hash(options.to_hash, :parse_contact)) unless options.nil?
+
+      response = request(NeuralCleanConversation.resources_path, body)
+      collection = []
+      response.each do |conversation|
+        collection.push(NeuralCleanConversation.new(**conversation.merge(api: api)))
+      end
+      collection
+    end
+
+    private
+
+    def request(path, body)
+      api.execute(
+        method: :put,
+        path: path,
+        payload: JSON.dump(body)
+      )
+    end
+
+    # For Ruby < 3.0 support, as it doesn't support Hash.except
+    def delete_from_hash(hash, to_delete)
+      hash.delete(to_delete)
+      hash
+    end
+  end
+end

data/lib/nylas/neural_categorizer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a the Neural Categorizer object.
+  # @see https://developer.nylas.com/docs/intelligence/categorizer/#categorize-message-response
+  class NeuralCategorizer < Message
+    include Model
+    self.resources_path = "/neural/categorize"
+    allows_operations(listable: true)
+
+    attribute :categorizer, :categorize
+    # Overrides Message's label attribute as currently categorize returns
+    # list of strings for labels instead of label object types
+    has_n_of_attribute :labels, :string
+
+    inherit_attributes
+
+    def recategorize(category)
+      body = { message_id: id, category: category }
+      api.execute(
+        method: :post,
+        path: "#{resources_path}/feedback",
+        payload: JSON.dump(body)
+      )
+      list = api.neural.categorize([id])
+      list[0]
+    end
+  end
+end

data/lib/nylas/neural_clean_conversation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a the Neural Clean Conversations object.
+  # @see https://developer.nylas.com/docs/intelligence/clean-conversations/#clean-conversation-response
+  class NeuralCleanConversation < Message
+    include Model
+    self.resources_path = "/neural/conversation"
+    allows_operations(listable: true)
+    IMAGE_REGEX = /[(']cid:(.*?)[)']/.freeze
+
+    attribute :conversation, :string
+    attribute :model_version, :string
+
+    inherit_attributes
+
+    # Parses image file IDs found in the clean conversation object and returns
+    # an array of File objects returned from the File API
+    def extract_images
+      return if conversation.nil?
+
+      files = []
+      matches = conversation.scan(IMAGE_REGEX)
+      matches.each do |match|
+        # After applying the regex, if there are IDs found they would be
+        # in the form of => 'cid:xxxx' (including apostrophes), so we discard
+        # everything before and after the file ID (denoted as xxxx above)
+        files.push(api.files.find(match))
+      end
+      files
+    end
+  end
+end

data/lib/nylas/neural_contact_link.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent the "Link" object in the Neural API's Signature Extraction Contact object
+  # @see https://developer.nylas.com/docs/intelligence/signature-extraction/#parse-signature-response
+  class NeuralContactLink
+    include Model::Attributable
+    attribute :description, :string
+    attribute :url, :string
+  end
+end

data/lib/nylas/neural_contact_name.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent the "Name" object in the Neural API's Signature Extraction Contact object
+  # @see https://developer.nylas.com/docs/intelligence/signature-extraction/#parse-signature-response
+  class NeuralContactName
+    include Model::Attributable
+    attribute :first_name, :string
+    attribute :last_name, :string
+  end
+end

data/lib/nylas/neural_message_options.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a the Neural Optical Character Recognition object.
+  # @see https://developer.nylas.com/docs/intelligence/optical-charecter-recognition/#ocr-response
+  class NeuralMessageOptions
+    attr_accessor :ignore_links, :ignore_images, :ignore_tables, :remove_conclusion_phrases,
+                  :images_as_markdown, :parse_contact
+
+    def initialize(ignore_links: nil,
+                   ignore_images: nil,
+                   ignore_tables: nil,
+                   remove_conclusion_phrases: nil,
+                   images_as_markdown: nil,
+                   parse_contact: nil)
+      @ignore_links = ignore_links
+      @ignore_images = ignore_images
+      @ignore_tables = ignore_tables
+      @remove_conclusion_phrases = remove_conclusion_phrases
+      @images_as_markdown = images_as_markdown
+      @parse_contact = parse_contact
+    end
+
+    def to_hash
+      hash = {}
+      hash[:ignore_links] = @ignore_links unless @ignore_links.nil?
+      hash[:ignore_images] = @ignore_images unless @ignore_images.nil?
+      hash[:ignore_tables] = @ignore_tables unless @ignore_tables.nil?
+      hash[:remove_conclusion_phrases] = @remove_conclusion_phrases unless @remove_conclusion_phrases.nil?
+      hash[:images_as_markdown] = @images_as_markdown unless @images_as_markdown.nil?
+      hash[:parse_contact] = @parse_contact unless @parse_contact.nil?
+      hash
+    end
+  end
+end

data/lib/nylas/neural_ocr.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a the Neural Optical Character Recognition object.
+  # @see https://developer.nylas.com/docs/intelligence/optical-charecter-recognition/#ocr-response
+  class NeuralOcr < File
+    include Model
+    self.resources_path = "/neural/ocr"
+    allows_operations(listable: true)
+
+    has_n_of_attribute :ocr, :string
+    attribute :processed_pages, :integer
+
+    inherit_attributes
+  end
+end

data/lib/nylas/neural_sentiment_analysis.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a the Neural Sentiment Analysis object.
+  # @see https://developer.nylas.com/docs/intelligence/sentiment-analysis/#sentiment-analysis-response-message
+  class NeuralSentimentAnalysis
+    include Model
+    self.resources_path = "/neural/sentiment"
+    allows_operations(listable: true)
+
+    attribute :account_id, :string
+    attribute :sentiment, :string
+    attribute :sentiment_score, :float
+    attribute :processed_length, :integer
+    attribute :text, :string
+  end
+end

data/lib/nylas/neural_signature_contact.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent the Neural API's Signature Extraction Contact object
+  # @see https://developer.nylas.com/docs/intelligence/signature-extraction/#parse-signature-response
+  class NeuralSignatureContact
+    include Model::Attributable
+    has_n_of_attribute :job_titles, :string
+    has_n_of_attribute :links, :neural_contact_link
+    has_n_of_attribute :phone_numbers, :string
+    has_n_of_attribute :emails, :string
+    has_n_of_attribute :names, :neural_contact_name
+
+    attr_accessor :api
+
+    # Creates a Nylas contact object compatible with the contact endpoints.
+    # Please note if multiple names or multiple job titles were parsed only
+    # the first set are used.
+    def to_contact_object
+      contact = merge_multiple_hashes([convert_names, convert_emails, convert_phone_numbers, convert_links])
+      contact[:job_title] = job_titles[0] unless job_titles.nil?
+      Contact.new(**contact.merge(api: api))
+    end
+
+    private
+
+    def convert_names
+      return {} if names.empty?
+
+      contact = {}
+      contact[:given_name] = names[0].first_name if names[0].first_name
+      contact[:surname] = names[0].last_name if names[0].last_name
+      contact
+    end
+
+    def convert_emails
+      return {} if emails.empty?
+
+      contact = {}
+      contact[:emails] = []
+      emails.each do |e|
+        contact[:emails].push(type: "personal", email: e)
+      end
+      contact
+    end
+
+    def convert_phone_numbers
+      return {} if phone_numbers.empty?
+
+      contact = {}
+      contact[:phone_numbers] = []
+      phone_numbers.each do |number|
+        contact[:phone_numbers].push(type: "mobile", number: number)
+      end
+      contact
+    end
+
+    def convert_links
+      return {} if links.empty?
+
+      contact = {}
+      contact[:web_pages] = []
+      links.each do |link|
+        type = "homepage"
+        type = link.description unless link.description.empty?
+        contact[:web_pages].push(type: type, url: link.url)
+      end
+      contact
+    end
+
+    # For Ruby 2.5 support as it doesn't support multiple hashes to merge at once
+    def merge_multiple_hashes(hashes_to_merge)
+      hash = {}
+      hashes_to_merge.each do |new_hash|
+        hash = hash.merge(new_hash)
+      end
+
+      hash
+    end
+  end
+end

data/lib/nylas/neural_signature_extraction.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a the Signature Extraction Schema.
+  # @see https://developer.nylas.com/docs/intelligence/signature-extraction/#signature-feedback-response
+  class NeuralSignatureExtraction < Message
+    include Model
+    self.resources_path = "/neural/signature"
+
+    attribute :signature, :string
+    attribute :model_version, :string
+    attribute :contacts, :neural_signature_contact
+
+    inherit_attributes
+
+    transfer :api, to: %i[contacts]
+  end
+end

data/lib/nylas/new_message.rb

@@ -26,7 +26,7 @@ module Nylas
     attribute :tracking, :message_tracking
 
     def send!
-      Message.new(api.execute(method: :post, path: "/send", payload: to_json).merge(api: api))
+      Message.new(**api.execute(method: :post, path: "/send", payload: to_json).merge(api: api))
     end
   end
 end

data/lib/nylas/raw_message.rb

@@ -11,8 +11,15 @@ module Nylas
     end
 
     def send!
-      Message.new(api.execute(method: :post, path: "/send", payload: mime_compatible_string,
-                              headers: { "Content-type" => "message/rfc822" }).merge(api: api))
+      Message.new(**api.execute(
+        method: :post,
+        path: "/send",
+        payload: mime_compatible_string,
+        headers: HEADERS
+      ).merge(api: api))
     end
+
+    HEADERS = { "Content-type" => "message/rfc822" }.freeze
+    private_constant :HEADERS
   end
 end

data/lib/nylas/room_resource.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Ruby representation of a Nylas Room Resource object
+  # @see https://developer.nylas.com/docs/api/#tag--Room-Resources
+  class RoomResource
+    include Model
+    self.resources_path = "/resources"
+    allows_operations(listable: true)
+
+    attribute :object, :string, read_only: true
+    attribute :email, :string, read_only: true
+    attribute :name, :string, read_only: true
+    attribute :capacity, :string, read_only: true
+    attribute :building, :string, read_only: true
+    attribute :floor_name, :string, read_only: true
+    attribute :floor_number, :string, read_only: true
+  end
+end

data/lib/nylas/rsvp.rb

@@ -13,8 +13,12 @@ module Nylas
     attr_accessor :notify_participants
 
     def save
-      api.execute(method: :post, path: "/send-rsvp", payload: attributes.serialize,
-                  query: { notify_participants: notify_participants })
+      api.execute(
+        method: :post,
+        path: "/send-rsvp",
+        payload: attributes.serialize_for_api,
+        query: { notify_participants: notify_participants }
+      )
     end
   end
 end

data/lib/nylas/thread.rb

@@ -23,6 +23,7 @@ module Nylas
     has_n_of_attribute :labels, :label
     has_n_of_attribute :folders, :folder
     has_n_of_attribute :message_ids, :string
+    has_n_of_attribute :messages, :message
     has_n_of_attribute :participants, :participant
     attribute :snippet, :string
     attribute :starred, :boolean

data/lib/nylas/types.rb

@@ -144,5 +144,16 @@ module Nylas
       end
     end
     Types.registry[:boolean] = BooleanType.new
+
+    # Type for attributes represented as floats.
+    class FloatType < ValueType
+      # @param value [Object] Strictly casts the passed in value to a boolean (must be true, not "" or 1)
+      def cast(value)
+        return nil if value.nil?
+
+        value.to_f
+      end
+    end
+    Types.registry[:float] = FloatType.new
   end
 end

data/lib/nylas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nylas
-  VERSION = "4.6.7"
+  VERSION = "5.3.0"
 end

data/lib/nylas/when.rb

@@ -8,7 +8,7 @@ module Nylas
 
     include Model::Attributable
 
-    attribute :object, :string
+    attribute :object, :string, read_only: true
 
     # when object == 'date'
     attribute :date, :date

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nylas
 version: !ruby/object:Gem::Version
-  version: 4.6.7
+  version: 5.3.0
 platform: ruby
 authors:
 - Nylas, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-22 00:00:00.000000000 Z
+date: 2021-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -270,6 +270,7 @@ files:
 - lib/nylas/account.rb
 - lib/nylas/api.rb
 - lib/nylas/calendar.rb
+- lib/nylas/categorize.rb
 - lib/nylas/collection.rb
 - lib/nylas/constraints.rb
 - lib/nylas/contact.rb
@@ -302,6 +303,16 @@ files:
 - lib/nylas/model/list_attribute_definition.rb
 - lib/nylas/model/transferable.rb
 - lib/nylas/native_authentication.rb
+- lib/nylas/neural.rb
+- lib/nylas/neural_categorizer.rb
+- lib/nylas/neural_clean_conversation.rb
+- lib/nylas/neural_contact_link.rb
+- lib/nylas/neural_contact_name.rb
+- lib/nylas/neural_message_options.rb
+- lib/nylas/neural_ocr.rb
+- lib/nylas/neural_sentiment_analysis.rb
+- lib/nylas/neural_signature_contact.rb
+- lib/nylas/neural_signature_extraction.rb
 - lib/nylas/new_message.rb
 - lib/nylas/nylas_date.rb
 - lib/nylas/participant.rb
@@ -310,6 +321,7 @@ files:
 - lib/nylas/raw_message.rb
 - lib/nylas/recurrence.rb
 - lib/nylas/registry.rb
+- lib/nylas/room_resource.rb
 - lib/nylas/rsvp.rb
 - lib/nylas/search_collection.rb
 - lib/nylas/thread.rb
@@ -345,7 +357,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.17
 signing_key:
 specification_version: 4
 summary: Gem for interacting with the Nylas API