nylas_v2 5.14.2

data/lib/nylas_v2/model/attributes.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module NylasV2
+  module Model
+    # Stores the actual model data to allow for type casting and clean/dirty checking
+    class Attributes
+      attr_accessor :data, :attribute_definitions
+
+      def initialize(attribute_definitions)
+        @attribute_definitions = attribute_definitions
+        @data = Registry.new(default_attributes)
+      end
+
+      def [](key)
+        data[key]
+      end
+
+      def []=(key, value)
+        data[key] = cast(key, value)
+      rescue NylasV2::Registry::MissingKeyError
+        # Don't crash when a new attribute is added
+      end
+
+      # Merges data into the registry while casting input types correctly
+      def merge(new_data)
+        new_data.each do |attribute_name, value|
+          self[attribute_name] = value
+        end
+      end
+
+      # Convert the object to hash
+      # @param keys [Array<String>] The keys included
+      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
+      # @return [Hash] The hash representation of the object
+      def to_h(keys: attribute_definitions.keys, enforce_read_only: false)
+        casted_data = {}
+        keys.each do |key|
+          value = attribute_to_hash(key, enforce_read_only)
+          # If the value is an empty hash but we specify that it is valid (via default value), serialize it
+          casted_data[key] = value unless value.nil? || (value.respond_to?(:empty?) && value.empty? &&
+            !(attribute_definitions[key].default == value && value.is_a?(Hash)))
+        end
+        casted_data
+      end
+
+      # Serialize the object
+      # @param keys [Array<String>] The keys included
+      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
+      # @return [String] The serialized object as a JSON string
+      def serialize(keys: attribute_definitions.keys, enforce_read_only: false)
+        JSON.dump(to_h(keys: keys, enforce_read_only: enforce_read_only))
+      end
+
+      # Serialize the object to an API-compatible JSON string
+      # @param keys [Array<String>] The keys included
+      # @return [String] The serialized object as a JSON string
+      def serialize_for_api(keys: attribute_definitions.keys)
+        serialize(keys: keys, enforce_read_only: true)
+      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)
+        attribute_definitions[key].cast(value)
+      rescue TypeError => e
+        raise TypeError, "#{key} #{e.message}"
+      end
+
+      def default_attributes
+        attribute_definitions.keys.zip([]).to_h
+      end
+
+      # Convert the attribute value as a hash
+      # @param key [String] The attribute's key
+      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
+      # @return [nil | Hash] The appropriately serialized value
+      def attribute_to_hash(key, enforce_read_only)
+        attribute_definition = attribute_definitions[key]
+        if enforce_read_only
+          attribute_definition.read_only == true ? nil : attribute_definition.serialize_for_api(self[key])
+        else
+          attribute_definition.serialize(self[key])
+        end
+      end
+    end
+  end
+end

data/lib/nylas_v2/model/list_attribute_definition.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module NylasV2
+  module Model
+    # Allows models to have an attribute which is a lists of another type of thing
+    class ListAttributeDefinition
+      attr_accessor :type_name, :read_only, :default
+
+      def initialize(type_name:, read_only:, default:)
+        self.type_name = type_name
+        self.read_only = read_only
+        self.default = default
+      end
+
+      def cast(list)
+        return default if list.nil? || list.empty?
+
+        list.map { |item| type.cast(item) }
+      end
+
+      def serialize(list, enforce_read_only: false)
+        list = default if list.nil? || list.empty?
+        if enforce_read_only
+          list.map { |item| type.serialize_for_api(item) }
+        else
+          list.map { |item| type.serialize(item) }
+        end
+      end
+
+      def serialize_for_api(list)
+        serialize(list, enforce_read_only: true)
+      end
+
+      def type
+        Types.registry[type_name]
+      end
+    end
+  end
+end

data/lib/nylas_v2/model/transferable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module NylasV2
+  module Model
+    # Allows definition of attributes, which should transfer to other dependent attributes
+    module Transferable
+      def self.included(model)
+        model.extend(ClassMethods)
+        model.init_attribute_recipients
+      end
+
+      def initialize(**initial_data)
+        assign(**initial_data)
+        transfer_attributes
+      end
+
+      private
+
+      def transfer_attributes
+        self.class.attribute_recipients.each_pair do |name, recipient_names|
+          value = send(:"#{name}")
+          next if value.nil?
+
+          recipient_names.each do |recipient_name|
+            recipient = send(:"#{recipient_name}")
+            transfer_to_recipient(name, value, recipient) unless recipient.nil?
+          end
+        end
+      end
+
+      def transfer_to_recipient(name, value, recipient)
+        if recipient.respond_to?(:each)
+          recipient.each { |item| item.send(:"#{name}=", value) }
+        else
+          recipient.send(:"#{name}=", value)
+        end
+      end
+
+      # Methods to call when tweaking Transferable classes
+      module ClassMethods
+        attr_accessor :attribute_recipients
+
+        def init_attribute_recipients
+          self.attribute_recipients ||= {}
+        end
+
+        def transfer(*attributes, **opts)
+          attributes.each { |name| self.attribute_recipients[name] = opts[:to] }
+        end
+      end
+    end
+  end
+end

data/lib/nylas_v2/model.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require_relative "model/attribute_definition"
+require_relative "model/list_attribute_definition"
+require_relative "model/attributable"
+require_relative "model/attributes"
+require_relative "model/transferable"
+module NylasV2
+  # Include this to define a class to represent an object returned from the API
+  module Model
+    attr_accessor :api
+
+    def model_class
+      self.class
+    end
+
+    def self.included(model)
+      model.include(Attributable)
+      model.include(Transferable)
+      model.extend(ClassMethods)
+      model.extend(Forwardable)
+      model.def_delegators :model_class, :creatable?, :filterable?, :listable?, :searchable?, :showable?,
+                           :updatable?, :destroyable?, :id_listable?, :countable?
+      model.init_operations
+    end
+
+    def save
+      result = if persisted?
+                 raise ModelNotUpdatableError, self unless updatable?
+
+                 update_call(attributes.serialize_for_api)
+               else
+                 create
+               end
+      attributes.merge(result)
+    end
+
+    def persisted?
+      !id.nil?
+    end
+
+    def execute(method:, payload: nil, path:, query: {}, auth_method: self.auth_method)
+      api.execute(method: method, payload: payload, path: path, query: query, auth_method: auth_method)
+    end
+
+    def create
+      raise ModelNotCreatableError, self unless creatable?
+
+      execute(
+        method: :post,
+        payload: attributes.serialize_for_api,
+        path: resources_path,
+        query: query_params
+      )
+    end
+
+    def update(**data)
+      raise ModelNotUpdatableError, model_class unless updatable?
+
+      attributes.merge(**data)
+      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)
+    end
+
+    def reload
+      assign(**execute(method: :get, path: resource_path))
+      true
+    end
+
+    def resource_path
+      "#{resources_path}/#{id}"
+    end
+
+    def resources_path
+      self.class.resources_path(api: api)
+    end
+
+    def auth_method
+      self.class.auth_method(api: api)
+    end
+
+    def destroy
+      raise ModelNotDestroyableError, self unless destroyable?
+
+      execute(method: :delete, path: resource_path, query: query_params)
+    end
+
+    # @return [String] JSON String of the model.
+    def to_json(_opts = {})
+      JSON.dump(to_h)
+    end
+
+    private
+
+    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
+
+    # Allows you to narrow in exactly what kind of model you're working with
+    module ClassMethods
+      attr_accessor :raw_mime_type, :creatable, :showable, :filterable, :searchable, :listable, :updatable,
+                    :destroyable, :id_listable, :countable
+      attr_writer :resources_path, :auth_method
+
+      def init_operations
+        self.creatable = false
+        self.showable = false
+        self.listable = false
+        self.filterable = false
+        self.searchable = false
+        self.updatable = false
+        self.destroyable = false
+        self.id_listable = false
+        self.countable = false
+      end
+
+      def creatable?
+        creatable
+      end
+
+      def showable?
+        showable
+      end
+
+      def listable?
+        listable
+      end
+
+      def filterable?
+        filterable
+      end
+
+      def searchable?
+        searchable
+      end
+
+      def updatable?
+        updatable
+      end
+
+      def destroyable?
+        destroyable
+      end
+
+      def id_listable?
+        id_listable
+      end
+
+      def countable?
+        countable
+      end
+
+      def resources_path(*)
+        @resources_path
+      end
+
+      def auth_method(*)
+        @auth_method || HttpClient::AuthMethod::BEARER
+      end
+
+      def exposable_as_raw?
+        !raw_mime_type.nil?
+      end
+
+      def from_json(json, api:)
+        from_hash(JSON.parse(json, symbolize_names: true), api: api)
+      end
+
+      def from_hash(data, api:)
+        instance = new(**data.merge(api: api))
+        instance
+      end
+    end
+  end
+end

data/lib/nylas_v2/native_authentication.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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,
+                     scopes: nil)
+      scopes ||= %w[email calendar contacts]
+      scopes = scopes.join(",") unless scopes.is_a?(String)
+      code = retrieve_code(name: name, email_address: email_address, provider: provider,
+                           settings: settings, reauth_account_id: reauth_account_id, scopes: scopes)
+
+      exchange_code_for_access_token(code)
+    end
+
+    private
+
+    def retrieve_code(name:, email_address:, provider:, settings:, reauth_account_id:, scopes:)
+      payload = { client_id: api.client.app_id, name: name, email_address: email_address,
+                  provider: provider, settings: settings, scopes: scopes }
+      payload[:reauth_account_id] = reauth_account_id
+      response = api.execute(method: :post, path: "/connect/authorize", payload: JSON.dump(payload))
+      response[:code]
+    end
+
+    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_v2/neural.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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_v2/neural_categorizer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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"
+    self.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_v2/neural_clean_conversation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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"
+    self.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_v2/neural_contact_link.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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_v2/neural_contact_name.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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_v2/neural_message_options.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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_v2/neural_ocr.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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"
+    self.listable = true
+
+    has_n_of_attribute :ocr, :string
+    attribute :processed_pages, :integer
+
+    inherit_attributes
+  end
+end

data/lib/nylas_v2/neural_sentiment_analysis.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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"
+    self.listable = true
+
+    attribute :account_id, :string
+    attribute :sentiment, :string
+    attribute :sentiment_score, :float
+    attribute :processed_length, :integer
+    attribute :text, :string
+  end
+end