nylas 5.6.1 → 5.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54c46b764fd777bee7eb27539bd6dc54ad253b76a242db3cfa9c969e128c05e4
-  data.tar.gz: 2c0876d20db34b5796ec2d6c21c487de8d661cd6041a899604b6dcf594ffa8f1
+  metadata.gz: b390b7c22a3dfcc7a4eed1db3966295d71a5f8928efd4b81bedbabd0c7bac0dc
+  data.tar.gz: d27e92177ddf12626917c2b20334bc74bcc703f04d5d68721375429aa4ce06fe
 SHA512:
-  metadata.gz: f70e5d14160b41bb0b50fddc2a17141fd16405fc9f0460a0fbdeaf7ac9ff356332a0400167322c63e7c0a1d0673a1b234a57e1427d9682c8bf88e59e0ca2a5c6
-  data.tar.gz: f4494a94a6bf17fc43be9af8961ce9ceb0ce9b97e76b06e598bf4214934d81561378f3519c3715a536d2b8703194bfe6ba047496e1ab425b3bdb99b18e46bc90
+  metadata.gz: c0d5c385aa98002eceed26178f6d63e60950344fd48cd229c2c32fd4b3998c837db894ca2fd883da8886f4dd91ee8fef01b07885f7e3941ef5b17d8bb4c2afe6
+  data.tar.gz: 86d6663b12da809962c28d6284ee5a22c90951ac9055bbadce90a347a55061ac1c67ff1feeb7e22b711d2311f24df2d0928e858be3ca03074e9e109022199b62

data/lib/nylas/account.rb

@@ -8,12 +8,15 @@ module Nylas
     self.listable = true
     self.showable = true
     self.updatable = true
+    self.destroyable = true
+    self.auth_method = HttpClient::AuthMethod::BASIC
 
     attribute :id, :string, read_only: true
     attribute :account_id, :string, read_only: true
     attribute :billing_state, :string, read_only: true
     attribute :sync_state, :string, read_only: true
     attribute :provider, :string, read_only: true
+    attribute :authentication_type, :string, read_only: true
 
     attribute :email, :string, read_only: true
     attribute :trial, :boolean, read_only: true
@@ -36,6 +39,15 @@ module Nylas
       response[:success]
     end
 
+    # Return information about an account's access token
+    # @param access_token [String] The access token to inquire about
+    # @return [TokenInfo] The access token information
+    def token_info(access_token)
+      payload = JSON.dump(access_token: access_token)
+      response = execute(method: :post, path: "#{resource_path}/token-info", payload: payload)
+      TokenInfo.new(**response)
+    end
+
     def self.resources_path(api:)
       "/a/#{api.app_id}/accounts"
     end

data/lib/nylas/api.rb

@@ -130,6 +130,16 @@ module Nylas
       @room_resources ||= Collection.new(model: RoomResource, api: self)
     end
 
+    # @return[Collection<JobStatus>] A queryable collection of {JobStatus} objects
+    def job_statuses
+      @job_statuses ||= JobStatusCollection.new(model: JobStatus, api: self)
+    end
+
+    # @return[OutboxCollection] A collection of Outbox operations
+    def outbox
+      @outbox ||= Outbox.new(api: self)
+    end
+
     # @return[SchedulerCollection<Scheduler>] A queryable collection of {Scheduler} objects
     def scheduler
       # Make a deep copy of the API as the scheduler API uses a different base URL
@@ -138,7 +148,7 @@ module Nylas
       @scheduler ||= SchedulerCollection.new(model: Scheduler, api: scheduler_api)
     end
 
-    # @return[Neural] A {Neural} object that provides
+    # @return[Neural] A collection of Neural operations
     def neural
       @neural ||= Neural.new(api: self)
     end
@@ -155,12 +165,36 @@ module Nylas
       response.code == 200 && response.empty?
     end
 
+    # Returns the application details
+    # @return [ApplicationDetail] The application details
+    def application_details
+      response = client.as(client.app_secret).execute(
+        method: :get,
+        path: "/a/#{app_id}",
+        auth_method: HttpClient::AuthMethod::BASIC
+      )
+      ApplicationDetail.new(**response)
+    end
+
+    # Updates the application details
+    # @param application_details [ApplicationDetail] The updated application details
+    # @return [ApplicationDetails] The updated application details, returned from the server
+    def update_application_details(application_details)
+      response = client.as(client.app_secret).execute(
+        method: :put,
+        path: "/a/#{app_id}",
+        payload: JSON.dump(application_details.to_h),
+        auth_method: HttpClient::AuthMethod::BASIC
+      )
+      ApplicationDetail.new(**response)
+    end
+
     # Returns list of IP addresses
     # @return [Hash]
     # hash has keys of :updated_at (unix timestamp) and :ip_addresses (array of strings)
     def ip_addresses
       path = "/a/#{app_id}/ip_addresses"
-      client.as(client.app_secret).get(path: path)
+      client.as(client.app_secret).get(path: path, auth_method: HttpClient::AuthMethod::BASIC)
     end
 
     # @param message [Hash, String, #send!]
@@ -172,7 +206,7 @@ module Nylas
     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
+    # @param access_token [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))

data/lib/nylas/application_details.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a Nylas Application Detail object.
+  # @see https://developer.nylas.com/docs/api/#get/a/client_id
+  class ApplicationDetail
+    include Model::Attributable
+
+    attribute :application_name, :string
+    attribute :icon_url, :string
+    has_n_of_attribute :redirect_uris, :string
+  end
+end

data/lib/nylas/calendar.rb

@@ -22,6 +22,7 @@ module Nylas
 
     attribute :read_only, :boolean
     attribute :metadata, :hash
+    attribute :job_status_id, :string, read_only: true
 
     def read_only?
       read_only == true

data/lib/nylas/calendar_collection.rb

@@ -5,47 +5,53 @@ module Nylas
   # @see https://developer.nylas.com/docs/connectivity/calendar
   class CalendarCollection < Collection
     def availability(duration_minutes:,
-                     interval:,
+                     interval_minutes:,
                      start_time:,
                      end_time:,
-                     emails:,
+                     emails: [],
                      buffer: nil,
                      round_robin: nil,
                      free_busy: [],
-                     open_hours: [])
+                     open_hours: [],
+                     calendars: [])
+      validate_calendars_or_emails(calendars, emails)
       validate_open_hours(emails, free_busy, open_hours) unless open_hours.empty?
 
       execute_availability("/calendars/availability",
                            duration_minutes: duration_minutes,
-                           interval: interval,
+                           interval_minutes: interval_minutes,
                            start_time: start_time,
                            end_time: end_time,
                            emails: emails,
                            buffer: buffer,
                            round_robin: round_robin,
                            free_busy: free_busy,
-                           open_hours: open_hours)
+                           open_hours: open_hours,
+                           calendars: calendars)
     end
 
     def consecutive_availability(duration_minutes:,
-                                 interval:,
+                                 interval_minutes:,
                                  start_time:,
                                  end_time:,
-                                 emails:,
+                                 emails: [],
                                  buffer: nil,
                                  free_busy: [],
-                                 open_hours: [])
+                                 open_hours: [],
+                                 calendars: [])
+      validate_calendars_or_emails(emails, calendars)
       validate_open_hours(emails, free_busy, open_hours) unless open_hours.empty?
 
       execute_availability("/calendars/availability/consecutive",
                            duration_minutes: duration_minutes,
-                           interval: interval,
+                           interval_minutes: interval_minutes,
                            start_time: start_time,
                            end_time: end_time,
                            emails: emails,
                            buffer: buffer,
                            free_busy: free_busy,
-                           open_hours: open_hours)
+                           open_hours: open_hours,
+                           calendars: calendars)
     end
 
     private
@@ -58,6 +64,12 @@ module Nylas
       )
     end
 
+    def validate_calendars_or_emails(calendars, emails)
+      return unless calendars.empty? && emails.empty?
+
+      raise ArgumentError, "You must provide at least one of 'emails' or 'calendars'"
+    end
+
     def validate_open_hours(emails, free_busy, open_hours)
       raise TypeError, "open_hours' must be an array." unless open_hours.is_a?(Array)
 

data/lib/nylas/collection.rb

@@ -139,7 +139,7 @@ module Nylas
     # @return [Hash] Specification for request to be passed to {API#execute}
     def to_be_executed
       { method: :get, path: resources_path, query: constraints.to_query,
-        headers: constraints.to_headers }
+        headers: constraints.to_headers, auth_method: model.auth_method }
     end
 
     # Retrieves the data from the API for the particular constraints

data/lib/nylas/component.rb

@@ -6,6 +6,7 @@ module Nylas
     include Model
     allows_operations(creatable: true, listable: true, filterable: true, showable: true, updatable: true,
                       destroyable: true)
+    self.auth_method = HttpClient::AuthMethod::BASIC
 
     attribute :id, :string, read_only: true
     attribute :account_id, :string

data/lib/nylas/contact.rb

@@ -30,6 +30,7 @@ module Nylas
     attribute :office_location, :string
     attribute :notes, :string
     attribute :source, :string
+    attribute :job_status_id, :string, read_only: true
 
     has_n_of_attribute :groups, :contact_group
     has_n_of_attribute :emails, :email_address

data/lib/nylas/draft.rb

@@ -36,6 +36,7 @@ module Nylas
     has_n_of_attribute :labels, :label
 
     attribute :tracking, :message_tracking
+    attribute :job_status_id, :string, read_only: true
 
     transfer :api, to: %i[events files folder labels]
 

data/lib/nylas/event.rb

@@ -31,6 +31,7 @@ module Nylas
     attribute :conferencing, :event_conferencing
     has_n_of_attribute :notifications, :event_notification
     attribute :original_start_time, :unix_timestamp
+    attribute :job_status_id, :string, read_only: true
 
     attr_accessor :notify_participants
 
@@ -59,8 +60,47 @@ module Nylas
       rsvp.save
     end
 
+    # Generate an ICS file server-side, from an Event
+    # @param ical_uid [String] Unique identifier used events across calendaring systems
+    # @param method [String] Description of invitation and response methods for attendees
+    # @param prodid [String] Company-specific unique product identifier
+    # @return [String] String for writing directly into an ICS file
+    def generate_ics(ical_uid: nil, method: nil, prodid: nil)
+      raise ArgumentError, "Cannot generate an ICS file for an event without a Calendar ID or when set" unless
+        calendar_id && self.when
+
+      payload = build_ics_event_payload(ical_uid, method, prodid)
+      response = api.execute(
+        method: :post,
+        path: "#{resources_path}/to-ics",
+        payload: JSON.dump(payload)
+      )
+
+      response[:ics]
+    end
+
     private
 
+    def build_ics_event_payload(ical_uid, method, prodid)
+      payload = {}
+      if id
+        payload[:event_id] = id
+      else
+        payload = to_h(enforce_read_only: true)
+      end
+      ics_options = build_ics_options_payload(ical_uid, method, prodid)
+      payload["ics_options"] = ics_options unless ics_options.empty?
+      payload
+    end
+
+    def build_ics_options_payload(ical_uid, method, prodid)
+      payload = {}
+      payload["ical_uid"] = ical_uid if ical_uid
+      payload["method"] = method if method
+      payload["prodid"] = prodid if prodid
+      payload
+    end
+
     def query_params
       if notify_participants.nil?
         {}

data/lib/nylas/folder.rb

@@ -13,12 +13,12 @@ module Nylas
     self.updatable = true
     self.destroyable = true
 
-    attribute :id, :string
-    attribute :account_id, :string
-
-    attribute :object, :string
+    attribute :id, :string, read_only: true
+    attribute :account_id, :string, read_only: true
+    attribute :object, :string, read_only: true
 
     attribute :name, :string
     attribute :display_name, :string
+    attribute :job_status_id, :string, read_only: true
   end
 end

data/lib/nylas/http_client.rb

@@ -2,10 +2,16 @@
 
 module Nylas
   require "yajl"
+  require "base64"
 
   # 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
+    module AuthMethod
+      BEARER = 1
+      BASIC = 2
+    end
+
+    HTTP_SUCCESS_CODES = [200, 201, 202, 302].freeze
 
     HTTP_CODE_TO_EXCEPTIONS = {
       400 => InvalidRequest,
@@ -33,7 +39,8 @@ module Nylas
       "/delta/longpoll" => 3650,
       "/delta/streaming" => 3650
     }.freeze
-    SUPPORTED_API_VERSION = "2.2"
+
+    SUPPORTED_API_VERSION = "2.5"
 
     include Logging
     attr_accessor :api_server
@@ -73,9 +80,10 @@ module Nylas
     # @param query [Hash] (Optional, defaults to {}) - Hash of names and values to include in the query
     #                      section of the URI fragment
     # @param payload [String,Hash] (Optional, defaults to nil) - Body to send with the request.
+    # @param auth_method [AuthMethod] (Optional, defaults to BEARER) - The authentication method.
     # @return [Array Hash Stringn]
     # rubocop:disable Metrics/MethodLength
-    def execute(method:, path: nil, headers: {}, query: {}, payload: nil)
+    def execute(method:, path: nil, headers: {}, query: {}, payload: nil, auth_method: nil)
       timeout = ENDPOINT_TIMEOUTS.fetch(path, 230)
       request = build_request(
         method: method,
@@ -83,7 +91,8 @@ module Nylas
         headers: headers,
         query: query,
         payload: payload,
-        timeout: timeout
+        timeout: timeout,
+        auth_method: auth_method || AuthMethod::BEARER
       )
       rest_client_execute(**request) do |response, _request, result|
         content_type = nil
@@ -107,35 +116,64 @@ module Nylas
     inform_on :execute, level: :debug,
                         also_log: { result: true, values: %i[method url path headers query payload] }
 
-    def build_request(method:, path: nil, headers: {}, query: {}, payload: nil, timeout: nil)
+    def build_request(
+      method:,
+      path: nil,
+      headers: {},
+      query: {},
+      payload: nil,
+      timeout: nil,
+      auth_method: nil
+    )
       url ||= url_for_path(path)
       url = add_query_params_to_url(url, query)
-      resulting_headers = default_headers.merge(headers)
+      resulting_headers = default_headers.merge(headers).merge(auth_header(auth_method))
       { method: method, url: url, payload: payload, headers: resulting_headers, timeout: timeout }
     end
 
     # Syntactical sugar for making GET requests via the API.
     # @see #execute
-    def get(path: nil, headers: {}, query: {})
-      execute(method: :get, path: path, query: query, headers: headers)
+    def get(path: nil, headers: {}, query: {}, auth_method: nil)
+      execute(method: :get, path: path, query: query, headers: headers, auth_method: auth_method)
     end
 
     # Syntactical sugar for making POST requests via the API.
     # @see #execute
-    def post(path: nil, payload: nil, headers: {}, query: {})
-      execute(method: :post, path: path, headers: headers, query: query, payload: payload)
+    def post(path: nil, payload: nil, headers: {}, query: {}, auth_method: nil)
+      execute(
+        method: :post,
+        path: path,
+        headers: headers,
+        query: query,
+        payload: payload,
+        auth_method: auth_method
+      )
     end
 
     # Syntactical sugar for making PUT requests via the API.
     # @see #execute
-    def put(path: nil, payload:, headers: {}, query: {})
-      execute(method: :put, path: path, headers: headers, query: query, payload: payload)
+    def put(path: nil, payload:, headers: {}, query: {}, auth_method: nil)
+      execute(
+        method: :put,
+        path: path,
+        headers: headers,
+        query: query,
+        payload: payload,
+        auth_method: auth_method
+      )
     end
 
     # Syntactical sugar for making DELETE requests via the API.
     # @see #execute
-    def delete(path: nil, payload: nil, headers: {}, query: {})
-      execute(method: :delete, path: path, headers: headers, query: query, payload: payload)
+    def delete(path: nil, payload: nil, headers: {}, query: {}, auth_method: nil)
+      execute(
+        method: :delete,
+        path: path,
+        headers: headers,
+        query: query,
+        payload: payload,
+        auth_method: auth_method
+      )
     end
 
     def default_headers
@@ -216,5 +254,18 @@ module Nylas
 
       query
     end
+
+    def auth_header(auth_method)
+      authorization_string = case auth_method
+                             when AuthMethod::BEARER
+                               "Bearer #{access_token}"
+                             when AuthMethod::BASIC
+                               "Basic #{Base64.encode64("#{access_token}:")}"
+                             else
+                               "Bearer #{access_token}"
+                             end
+
+      { "Authorization" => authorization_string }
+    end
   end
 end

data/lib/nylas/job_status.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Ruby representation of a Nylas Job Status object
+  # @see https://developer.nylas.com/docs/api/#tag--Job-Status
+  class JobStatus
+    include Model
+    self.resources_path = "/job-statuses"
+    allows_operations(listable: true)
+
+    attribute :id, :string, read_only: true
+    attribute :account_id, :string, read_only: true
+    attribute :job_status_id, :string, read_only: true
+    attribute :action, :string, read_only: true
+    attribute :object, :string, read_only: true
+    attribute :status, :string, read_only: true
+    attribute :created_at, :unix_timestamp, read_only: true
+    attribute :reason, :string, read_only: true
+
+    # Returns the status of a job as a boolean
+    # @return [Boolean] If the job was successful
+    def successful?
+      status == "successful"
+    end
+  end
+end

data/lib/nylas/job_status_collection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Additional methods for some of Calendar's other functionality
+  # @see https://developer.nylas.com/docs/connectivity/calendar
+  class JobStatusCollection < Collection
+    def find_model(id)
+      response = api.execute(
+        **to_be_executed.merge(
+          path: "#{resources_path}/#{id}",
+          query: view_query
+        )
+      )
+
+      object_type = response[:object]
+      return OutboxJobStatus.from_hash(response, api: api) if object_type == "message"
+
+      model.from_hash(response, api: api)
+    end
+  end
+end

data/lib/nylas/label.rb

@@ -20,5 +20,6 @@ module Nylas
 
     attribute :name, :string
     attribute :display_name, :string
+    attribute :job_status_id, :string, read_only: true
   end
 end

data/lib/nylas/message.rb

@@ -37,6 +37,7 @@ module Nylas
     attribute :folder, :folder
     attribute :folder_id, :string
     attribute :metadata, :hash
+    attribute :job_status_id, :string, read_only: true
 
     has_n_of_attribute :labels, :label, read_only: true
     has_n_of_attribute :label_ids, :string

data/lib/nylas/model.rb

@@ -39,8 +39,8 @@ module Nylas
       !id.nil?
     end
 
-    def execute(method:, payload: nil, path:, query: {})
-      api.execute(method: method, payload: payload, path: path, query: query)
+    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
@@ -107,6 +107,10 @@ module Nylas
       self.class.resources_path(api: api)
     end
 
+    def auth_method
+      self.class.auth_method(api: api)
+    end
+
     def destroy
       raise ModelNotDestroyableError, self unless destroyable?
 
@@ -138,7 +142,7 @@ module Nylas
     module ClassMethods
       attr_accessor :raw_mime_type, :creatable, :showable, :filterable, :searchable, :listable, :updatable,
                     :destroyable
-      attr_writer :resources_path
+      attr_writer :resources_path, :auth_method
 
       def allows_operations(creatable: false, showable: false, listable: false, filterable: false,
                             searchable: false, updatable: false, destroyable: false)
@@ -184,6 +188,10 @@ module Nylas
         @resources_path
       end
 
+      def auth_method(*)
+        @auth_method || HttpClient::AuthMethod::BEARER
+      end
+
       def exposable_as_raw?
         !raw_mime_type.nil?
       end

data/lib/nylas/outbox.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Methods for Outbox functionality
+  # @see https://developer.nylas.com/docs/api/#tag--Outbox
+  class Outbox
+    attr_accessor :api
+
+    def initialize(api:)
+      self.api = api
+    end
+
+    def outbox_path
+      @outbox_path ||= "/v2/outbox"
+    end
+
+    # rubocop:disable Layout/LineLength
+    # Send a message via Outbox
+    # @param draft [Draft, OutboxMessage] The message to send
+    # @param send_at [Numeric] The date and time to send the message. If not set, Outbox will send this message immediately.
+    # @param retry_limit_datetime [Numeric] The date and time to stop retry attempts for a message. If not set, it defaults to 24 hours after send_at.
+    # @return [OutboxJobStatus] The outbox job status status and message data
+    # rubocop:enable Layout/LineLength
+    def send(draft, send_at: nil, retry_limit_datetime: nil)
+      message = draft.to_h(enforce_read_only: true)
+      message.merge!(validate_set_date_time(send_at, retry_limit_datetime))
+      outbox_response = api.execute(
+        method: :post,
+        path: outbox_path,
+        payload: JSON.dump(message)
+      )
+
+      OutboxJobStatus.new(**outbox_response)
+    end
+
+    # rubocop:disable Layout/LineLength
+    # Update a scheduled Outbox message
+    # @param job_status_id [String] The ID of the outbox job status
+    # @param message [Draft, OutboxMessage] The message object with updated values
+    # @param send_at [Numeric] The date and time to send the message. If not set, Outbox will send this message immediately.
+    # @param retry_limit_datetime [Numeric] The date and time to stop retry attempts for a message. If not set, it defaults to 24 hours after send_at.
+    # @return [OutboxJobStatus] The updated outbox job status status and message data
+    # rubocop:enable Layout/LineLength
+    def update(job_status_id, message: nil, send_at: nil, retry_limit_datetime: nil)
+      payload = {}
+      payload.merge!(message.to_h(enforce_read_only: true)) if message
+      payload.merge!(validate_set_date_time(send_at, retry_limit_datetime))
+      outbox_response = api.execute(
+        method: :patch,
+        path: "#{outbox_path}/#{job_status_id}",
+        payload: JSON.dump(payload)
+      )
+
+      OutboxJobStatus.new(**outbox_response)
+    end
+
+    # Delete a scheduled Outbox message
+    # @param job_status_id [String] The ID of the outbox job status to delete
+    # @return [void]
+    def delete(job_status_id)
+      api.execute(
+        method: :delete,
+        path: "#{outbox_path}/#{job_status_id}"
+      )
+    end
+
+    # SendGrid - Check Authentication and Verification Status
+    # @return [SendGridVerifiedStatus] The SendGrid Authentication and Verification Status
+    def send_grid_verification_status
+      response = api.execute(
+        method: :get,
+        path: "#{outbox_path}/onboard/verified_status"
+      )
+
+      raise "Verification status not present in response" if response.key?("results")
+
+      SendGridVerifiedStatus.new(**response[:results])
+    end
+
+    # SendGrid -  Delete SendGrid Subuser and UAS Grant
+    # @param email [String] Email address for SendGrid subuser to delete
+    # @return [void]
+    def delete_send_grid_sub_user(email)
+      api.execute(
+        method: :delete,
+        path: "#{outbox_path}/onboard/subuser",
+        payload: JSON.dump({ email: email })
+      )
+    end
+
+    private
+
+    def validate_set_date_time(send_at, retry_limit_datetime)
+      hash = {}
+      hash[:send_at] = validate_send_at(send_at) if send_at
+      if retry_limit_datetime
+        hash[:retry_limit_datetime] = validate_retry_limit_datetime(send_at, retry_limit_datetime)
+      end
+
+      hash
+    end
+
+    def validate_send_at(send_at)
+      return send_at unless send_at != 0 && (send_at < Time.now.to_i)
+
+      raise ArgumentError, "Cannot set message to be sent at a time before the current time."
+    end
+
+    def validate_retry_limit_datetime(send_at, retry_limit_datetime)
+      valid_send_at = send_at && send_at != 0 ? send_at : Time.now.to_i
+      return retry_limit_datetime unless retry_limit_datetime != 0 && (retry_limit_datetime < valid_send_at)
+
+      raise ArgumentError, "Cannot set message to stop retrying before time to send at."
+    end
+  end
+end

data/lib/nylas/outbox_job_status.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Ruby representation of a Nylas Outbox Job Status object
+  # @see https://developer.nylas.com/docs/api/#post/v2/outbox
+  class OutboxJobStatus < JobStatus
+    include Model
+
+    attribute :send_at, :unix_timestamp
+    attribute :original_send_at, :unix_timestamp
+    attribute :message_id, :string
+    attribute :thread_id, :string
+    attribute :original_data, :outbox_message
+
+    transfer :api, to: %i[original_data]
+
+    inherit_attributes
+  end
+end

data/lib/nylas/outbox_message.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Ruby representation of a Nylas Outbox Message object
+  # @see https://developer.nylas.com/docs/api/#post/v2/outbox
+  class OutboxMessage < Draft
+    include Model
+
+    attribute :send_at, :unix_timestamp
+    attribute :retry_limit_datetime, :unix_timestamp
+    attribute :original_send_at, :unix_timestamp, read_only: true
+
+    transfer :api, to: %i[events files folder labels]
+
+    inherit_attributes
+  end
+end

data/lib/nylas/send_grid_verified_status.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Ruby representation of a Nylas Send Grid verified status object
+  # @see https://docs.nylas.com/reference#drafts
+  class SendGridVerifiedStatus
+    include Model::Attributable
+
+    attribute :domain_verified, :boolean
+    attribute :sender_verified, :boolean
+  end
+end

data/lib/nylas/token_info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent information about a Nylas access token.
+  # @see https://developer.nylas.com/docs/api/#post/a/client_id/accounts/id/token-info
+  class TokenInfo
+    include Model::Attributable
+
+    attribute :scopes, :string
+    attribute :state, :string
+    attribute :created_at, :unix_timestamp
+    attribute :updated_at, :unix_timestamp
+
+    # Returns the state of the token as a boolean
+    # @return [Boolean] If the token is active
+    def valid?
+      state == "valid"
+    end
+  end
+end

data/lib/nylas/version.rb

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

data/lib/nylas/webhook.rb

@@ -1,21 +1,95 @@
 # frozen_string_literal: true
 
+module WebhookState
+  # Module representing the possible 'state' values in a Webhook
+  # @see https://developer.nylas.com/docs/api#post/a/client_id/webhooks
+
+  ACTIVE = "active"
+  INACTIVE = "inactive"
+end
+
+module WebhookTrigger
+  # Module representing the possible 'trigger' values in a Webhook
+  # @see https://developer.nylas.com/docs/api#post/a/client_id/webhooks
+
+  ACCOUNT_CONNECTED = "account.connected"
+  ACCOUNT_RUNNING = "account.running"
+  ACCOUNT_STOPPED = "account.stopped"
+  ACCOUNT_INVALID = "account.invalid"
+  ACCOUNT_SYNC_ERROR = "account.sync_error"
+  MESSAGE_CREATED = "message.created"
+  MESSAGE_OPENED = "message.opened"
+  MESSAGE_LINK_CLICKED = "message.link_created"
+  MESSAGE_UPDATED = "message.updated"
+  MESSAGE_BOUNCED = "message.bounced"
+  THREAD_REPLIED = "thread.replied"
+  CONTACT_CREATED = "contact.created"
+  CONTACT_UPDATED = "contact.updated"
+  CONTACT_DELETED = "contact.deleted"
+  CALENDAR_CREATED = "calendar.created"
+  CALENDAR_UPDATED = "calendar.updated"
+  CALENDAR_DELETED = "calendar.deleted"
+  EVENT_CREATED = "event.created"
+  EVENT_UPDATED = "event.updated"
+  EVENT_DELETED = "event.deleted"
+  JOB_SUCCESSFUL = "job.successful"
+  JOB_FAILED = "job.failed"
+end
+
 module Nylas
   # Represents a webhook attached to your application.
   # @see https://docs.nylas.com/reference#webhooks
   class Webhook
     include Model
-    allows_operations(listable: true, showable: true)
-    attribute :id, :string
-    attribute :application_id, :string
+    allows_operations(creatable: true, listable: true, showable: true, updatable: true,
+                      destroyable: true)
+    self.auth_method = HttpClient::AuthMethod::BASIC
+    attribute :id, :string, read_only: true
+    attribute :application_id, :string, read_only: true
 
     attribute :callback_url, :string
     attribute :state, :string
-    attribute :version, :string
+    attribute :version, :string, read_only: true
     has_n_of_attribute :triggers, :string
 
+    STATE = [:inactive].freeze
+
+    def save
+      result = if persisted?
+                 update_call(update_payload)
+               else
+                 create
+               end
+
+      attributes.merge(result)
+    end
+
+    def save_all_attributes
+      save
+    end
+
+    def update(**data)
+      raise ArgumentError, "Only 'state' is allowed to be updated" if data.length > 1 || !data.key?(:state)
+
+      attributes.merge(**data)
+      payload = JSON.dump(data)
+      update_call(payload)
+
+      true
+    end
+
+    def update_all_attributes(**data)
+      update(**data)
+    end
+
     def self.resources_path(api:)
       "/a/#{api.app_id}/webhooks"
     end
+
+    private
+
+    def update_payload
+      JSON.dump({ state: state })
+    end
   end
 end

data/lib/nylas.rb

@@ -29,6 +29,8 @@ require_relative "nylas/registry"
 require_relative "nylas/types"
 require_relative "nylas/constraints"
 
+require_relative "nylas/http_client"
+require_relative "nylas/api"
 require_relative "nylas/collection"
 require_relative "nylas/model"
 
@@ -67,6 +69,8 @@ require_relative "nylas/free_busy_collection"
 require_relative "nylas/calendar_collection"
 require_relative "nylas/component_collection"
 require_relative "nylas/scheduler_collection"
+require_relative "nylas/job_status_collection"
+require_relative "nylas/outbox"
 
 # Models supported by the API
 require_relative "nylas/account"
@@ -84,6 +88,12 @@ require_relative "nylas/raw_message"
 require_relative "nylas/thread"
 require_relative "nylas/webhook"
 require_relative "nylas/scheduler"
+require_relative "nylas/job_status"
+require_relative "nylas/token_info"
+require_relative "nylas/application_details"
+require_relative "nylas/outbox_message"
+require_relative "nylas/outbox_job_status"
+require_relative "nylas/send_grid_verified_status"
 
 # Neural specific types
 require_relative "nylas/neural"
@@ -104,9 +114,6 @@ require_relative "nylas/scheduler_booking_confirmation"
 
 require_relative "nylas/native_authentication"
 
-require_relative "nylas/http_client"
-require_relative "nylas/api"
-
 require_relative "nylas/filter_attributes"
 # an SDK for interacting with the Nylas API
 # @see https://docs.nylas.com/reference
@@ -148,4 +155,6 @@ module Nylas
   Types.registry[:neural_contact_name] = Types::ModelType.new(model: NeuralContactName)
   Types.registry[:scheduler_config] = Types::ModelType.new(model: SchedulerConfig)
   Types.registry[:scheduler_time_slot] = Types::ModelType.new(model: SchedulerTimeSlot)
+  Types.registry[:job_status] = Types::ModelType.new(model: JobStatus)
+  Types.registry[:outbox_message] = Types::ModelType.new(model: OutboxMessage)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nylas
 version: !ruby/object:Gem::Version
-  version: 5.6.1
+  version: 5.9.0
 platform: ruby
 authors:
 - Nylas, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
+date: 2022-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,28 +58,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.0
+        version: 1.24.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.0
+        version: 1.24.1
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.20.1
+        version: 2.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.20.1
+        version: 2.7.0
 - !ruby/object:Gem::Dependency
   name: overcommit
   requirement: !ruby/object:Gem::Requirement
@@ -269,6 +269,7 @@ files:
 - lib/nylas.rb
 - lib/nylas/account.rb
 - lib/nylas/api.rb
+- lib/nylas/application_details.rb
 - lib/nylas/calendar.rb
 - lib/nylas/calendar_collection.rb
 - lib/nylas/categorize.rb
@@ -298,6 +299,8 @@ files:
 - lib/nylas/free_busy_collection.rb
 - lib/nylas/http_client.rb
 - lib/nylas/im_address.rb
+- lib/nylas/job_status.rb
+- lib/nylas/job_status_collection.rb
 - lib/nylas/label.rb
 - lib/nylas/logging.rb
 - lib/nylas/message.rb
@@ -323,6 +326,9 @@ files:
 - lib/nylas/new_message.rb
 - lib/nylas/nylas_date.rb
 - lib/nylas/open_hours.rb
+- lib/nylas/outbox.rb
+- lib/nylas/outbox_job_status.rb
+- lib/nylas/outbox_message.rb
 - lib/nylas/participant.rb
 - lib/nylas/phone_number.rb
 - lib/nylas/physical_address.rb
@@ -338,9 +344,11 @@ files:
 - lib/nylas/scheduler_config.rb
 - lib/nylas/scheduler_time_slot.rb
 - lib/nylas/search_collection.rb
+- lib/nylas/send_grid_verified_status.rb
 - lib/nylas/thread.rb
 - lib/nylas/time_slot.rb
 - lib/nylas/timespan.rb
+- lib/nylas/token_info.rb
 - lib/nylas/types.rb
 - lib/nylas/version.rb
 - lib/nylas/web_page.rb
@@ -371,7 +379,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.17
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Gem for interacting with the Nylas API