nylas 5.17.0 → 6.0.0.beta.1

data/lib/nylas/account.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Representation of the accounts for Account management purposes.
-  # @see https://docs.nylas.com/reference#account-management
-  class Account
-    include Model
-    self.listable = true
-    self.showable = true
-    self.updatable = true
-    self.destroyable = true
-    self.filterable = 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
-    attribute :metadata, :hash
-
-    def upgrade
-      response = execute(method: :post, path: "#{resource_path}/upgrade")
-      response[:success]
-    end
-
-    def downgrade
-      response = execute(method: :post, path: "#{resource_path}/downgrade")
-      response[:success]
-    end
-
-    def revoke_all(keep_access_token: nil)
-      payload = JSON.dump(keep_access_token: keep_access_token) if keep_access_token
-
-      response = execute(method: :post, path: "#{resource_path}/revoke-all", payload: payload)
-      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
-  end
-end

data/lib/nylas/api.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Methods to retrieve data from the Nylas API as Ruby objects
-  class API
-    attr_accessor :client
-
-    extend Forwardable
-    def_delegators :client, :execute, :get, :post, :put, :delete, :app_id, :api_server
-
-    include Logging
-
-    # @param client [HttpClient] Http Client to use for retrieving data
-    # @param app_id [String] Your application id from the Nylas Dashboard
-    # @param app_secret [String] Your application secret from the Nylas Dashboard
-    # @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.
-    # @return [Nylas::API]
-    def initialize(client: nil, app_id: nil, app_secret: nil, access_token: nil,
-                   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)
-    end
-
-    # @return [String] A Nylas access token for that particular user.
-    def authenticate(name:, email_address:, provider:, settings:, reauth_account_id: nil, scopes: nil,
-                     return_full_response: false)
-      NativeAuthentication.new(api: self).authenticate(
-        name: name,
-        email_address: email_address,
-        provider: provider,
-        settings: settings,
-        reauth_account_id: reauth_account_id,
-        scopes: scopes,
-        return_full_response: return_full_response
-      )
-    end
-
-    def authentication_url(redirect_uri:, scopes:, response_type: "code", login_hint: nil, state: nil,
-                           provider: nil, redirect_on_error: nil, disable_provider_selection: 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
-      params[:provider] = provider if provider
-      params[:redirect_on_error] = redirect_on_error if redirect_on_error
-      params[:disable_provider_selection] = disable_provider_selection if disable_provider_selection
-
-      "#{api_server}/oauth/authorize?#{URI.encode_www_form(params)}"
-    end
-
-    # Exchanges an authorization code for an access token
-    # @param code [String] The authorization code to exchange
-    # @param return_full_response [Boolean] If true, returns the full response body instead of just the token
-    # @return [String | Hash] Returns just the access token as a string, or the full response as a hash
-    def exchange_code_for_token(code, return_full_response: false)
-      data = {
-        "client_id" => app_id,
-        "client_secret" => client.app_secret,
-        "grant_type" => "authorization_code",
-        "code" => code
-      }
-
-      response = execute(method: :post, path: "/oauth/token", payload: data)
-      return_full_response ? response : response[:access_token]
-    end
-
-    # @return [Collection<Contact>] A queryable collection of Contacts
-    def contacts
-      @contacts ||= Collection.new(model: Contact, api: self)
-    end
-
-    # @return [Collection<ContactGroup>] A queryable collection of Contact Groups
-    def contact_groups
-      @contact_groups ||= Collection.new(model: ContactGroup, api: self)
-    end
-
-    # @return [CurrentAccount] The account details for whomevers access token is set
-    def current_account
-      prevent_calling_if_missing_access_token(:current_account)
-      CurrentAccount.from_hash(execute(method: :get, path: "/account"), api: self)
-    end
-
-    # @return [Collection<Account>] A queryable collection of {Account}s
-    def accounts
-      @accounts ||= Collection.new(model: Account, api: as(client.app_secret))
-    end
-
-    # @return [CalendarCollection<Calendar>] A queryable collection of {Calendar}s
-    def calendars
-      @calendars ||= CalendarCollection.new(model: Calendar, api: self)
-    end
-
-    # @return [DeltasCollection<Delta>] A queryable collection of Deltas, which are themselves a collection.
-    def deltas
-      @deltas ||= DeltasCollection.new(api: self)
-    end
-
-    # @return[Collection<Draft>] A queryable collection of {Draft} objects
-    def drafts
-      @drafts ||= Collection.new(model: Draft, api: self)
-    end
-
-    # @return [EventCollection<Event>] A queryable collection of {Event}s
-    def events
-      @events ||= EventCollection.new(model: Event, api: self)
-    end
-
-    # @return [Collection<Folder>] A queryable collection of {Folder}s
-    def folders
-      @folders ||= Collection.new(model: Folder, api: self)
-    end
-
-    # @return [Collection<File>] A queryable collection of {File}s
-    def files
-      @files ||= Collection.new(model: File, api: self)
-    end
-
-    # @return [Collection<Label>] A queryable collection of {Label} objects
-    def labels
-      @labels ||= Collection.new(model: Label, api: self)
-    end
-
-    # @return[Collection<Message>] A queryable collection of {Message} objects
-    def messages
-      @messages ||= Collection.new(model: Message, api: self)
-    end
-
-    # @return[Collection<RoomResource>] A queryable collection of {RoomResource} objects
-    def room_resources
-      @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
-      scheduler_api = Marshal.load(Marshal.dump(self))
-      scheduler_api.client.api_server = "https://api.schedule.nylas.com"
-      @scheduler ||= SchedulerCollection.new(model: Scheduler, api: scheduler_api)
-    end
-
-    # @return[Neural] A collection of Neural operations
-    def neural
-      @neural ||= Neural.new(api: self)
-    end
-
-    # @return [Collection<Component>] A queryable collection of {Component}s
-    def components
-      @components ||= ComponentCollection.new(model: Component, api: as(client.app_secret))
-    end
-
-    # Revokes access to the Nylas API for the given access token
-    # @return [Boolean]
-    def revoke(access_token)
-      response = client.as(access_token).post(path: "/oauth/revoke")
-      response.code == 200 && response.empty?
-    end
-
-    # 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, auth_method: HttpClient::AuthMethod::BASIC)
-    end
-
-    # @param message [Hash, String, #send!]
-    # @return [Message] The resulting message
-    def send!(message)
-      return message.send! if message.respond_to?(:send!)
-      return NewMessage.new(**message.merge(api: self)).send! if message.respond_to?(:key?)
-      return RawMessage.new(message, api: self).send! if message.is_a? String
-    end
-
-    # Allows you to get an API that acts as a different user but otherwise has the same settings
-    # @param 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))
-    end
-
-    # @return [Collection<Thread>] A queryable collection of Threads
-    def threads
-      @threads ||= Collection.new(model: Thread, api: self)
-    end
-
-    # @return [Collection<Webhook>] A queryable collection of {Webhook}s
-    def webhooks
-      @webhooks ||= Collection.new(model: Webhook, api: as(client.app_secret))
-    end
-
-    # TODO: Move this into calendar collection
-    def free_busy(emails:, start_time:, end_time:)
-      FreeBusyCollection.new(
-        api: self,
-        emails: emails,
-        start_time: start_time.to_i,
-        end_time: end_time.to_i
-      )
-    end
-
-    private
-
-    def prevent_calling_if_missing_access_token(method_name)
-      return if client.access_token && !client.access_token.empty?
-
-      raise NoAuthToken, method_name
-    end
-  end
-end

data/lib/nylas/application_details.rb

@@ -1,13 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Ruby bindings for the Nylas Calendar API
-  # @see https://docs.nylas.com/reference#calendars
-  class Calendar
-    include Model
-    self.resources_path = "/calendars"
-    self.creatable = true
-    self.listable = true
-    self.showable = true
-    self.filterable = true
-    self.updatable = true
-    self.destroyable = true
-    self.id_listable = true
-    self.countable = true
-
-    attribute :id, :string
-    attribute :account_id, :string
-
-    attribute :object, :string
-
-    attribute :name, :string
-    attribute :description, :string
-    attribute :is_primary, :boolean
-    attribute :location, :string
-    attribute :timezone, :string
-
-    attribute :read_only, :boolean
-    attribute :metadata, :hash
-    attribute :job_status_id, :string, read_only: true
-    attribute :hex_color, :string, read_only: true
-
-    def read_only?
-      read_only == true
-    end
-
-    def primary?
-      is_primary
-    end
-
-    def events
-      api.events.where(calendar_id: id)
-    end
-  end
-end

data/lib/nylas/calendar_collection.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Additional methods for some of Calendar's other functionality
-  # @see https://developer.nylas.com/docs/connectivity/calendar
-  class CalendarCollection < Collection
-    # Check multiple calendars to find available time slots for a single meeting
-    # @param duration_minutes [Integer] The total number of minutes the event should last
-    # @param interval_minutes [Integer] How many minutes it should check for availability
-    # @param start_time [Integer] The timestamp for the beginning of the event
-    # @param end_time [Integer] The timestamp for the end of the event
-    # @param emails [Array<String>] Emails on the same domain to check
-    # @param buffer [Integer] The amount of buffer time in minutes that you want around existing meetings
-    # @param round_robin [String] Finds available meeting times in a round-robin style
-    # @param event_collection_id [String] Unique identifier for a collection of events that are created
-    # @param free_busy [Array<Nylas::FreeBusy>] A list of free-busy data for users not in your organization
-    # @param open_hours [Array<Nylas::OpenHours>] Additional times email accounts are available
-    # @param calendars [Array] Check account and calendar IDs for free/busy status
-    # @return [Hash] The availability information; a list of time slots where all participants are available
-    def availability(duration_minutes:,
-                     interval_minutes:,
-                     start_time:,
-                     end_time:,
-                     emails: [],
-                     buffer: nil,
-                     round_robin: nil,
-                     event_collection_id: nil,
-                     free_busy: [],
-                     open_hours: [],
-                     calendars: [])
-      validate_calendars_or_emails(calendars, emails)
-      validate_open_hours(emails, free_busy, open_hours) unless open_hours.empty?
-
-      payload = {
-        duration_minutes: duration_minutes,
-        interval_minutes: interval_minutes,
-        start_time: start_time,
-        end_time: end_time,
-        emails: emails,
-        free_busy: free_busy.map(&:to_h),
-        open_hours: open_hours.map(&:to_h),
-        calendars: calendars
-      }
-      payload[:buffer] = buffer if buffer
-      payload[:round_robin] = round_robin if round_robin
-      payload[:event_collection_id] = event_collection_id if event_collection_id
-
-      execute_availability("/calendars/availability", **payload)
-    end
-
-    # Check multiple calendars to find availability for multiple meetings with several participants
-    # @param duration_minutes [Integer] The total number of minutes the event should last
-    # @param interval_minutes [Integer] How many minutes it should check for availability
-    # @param start_time [Integer] The timestamp for the beginning of the event
-    # @param end_time [Integer] The timestamp for the end of the event
-    # @param emails [Array<Array<String>>] Emails on the same domain to check
-    # @param buffer [Integer] The amount of buffer time in minutes that you want around existing meetings
-    # @param free_busy [Array<Nylas::FreeBusy>] A list of free-busy data for users not in your organization
-    # @param open_hours [Array<Nylas::OpenHours>] Additional times email accounts are available
-    # @param calendars [Array] Check account and calendar IDs for free/busy status
-    # @return [Hash] The availability information; a list of all possible groupings that share time slots
-    def consecutive_availability(duration_minutes:,
-                                 interval_minutes:,
-                                 start_time:,
-                                 end_time:,
-                                 emails: [],
-                                 buffer: nil,
-                                 free_busy: [],
-                                 open_hours: [],
-                                 calendars: [])
-      validate_calendars_or_emails(emails, calendars)
-      validate_open_hours(emails, free_busy, open_hours) unless open_hours.empty?
-
-      payload = {
-        duration_minutes: duration_minutes,
-        interval_minutes: interval_minutes,
-        start_time: start_time,
-        end_time: end_time,
-        emails: emails,
-        free_busy: free_busy.map(&:to_h),
-        open_hours: open_hours.map(&:to_h),
-        calendars: calendars
-      }
-      payload[:buffer] = buffer if buffer
-
-      execute_availability("/calendars/availability/consecutive", **payload)
-    end
-
-    private
-
-    def execute_availability(path, **payload)
-      api.execute(
-        method: :post,
-        path: path,
-        payload: JSON.dump(payload)
-      )
-    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)
-
-      open_hours_emails = map_open_hours_emails(open_hours)
-      free_busy_emails = map_free_busy_emails(free_busy)
-      emails = merge_arrays(emails) if emails[0].is_a?(Array)
-
-      open_hours_emails.each do |email|
-        next if emails.include?(email) || free_busy_emails.include?(email)
-
-        raise ArgumentError, "Open Hours cannot contain an email not present in the main email list or
-the free busy email list."
-      end
-    end
-
-    def map_open_hours_emails(open_hours)
-      open_hours_emails = []
-      open_hours.map do |oh|
-        open_hours_emails += oh.emails
-      end
-      open_hours_emails
-    end
-
-    def map_free_busy_emails(free_busy)
-      free_busy_emails = []
-      free_busy.map do |fb|
-        free_busy_emails.append(fb.email)
-      end
-      free_busy_emails
-    end
-
-    def merge_arrays(array)
-      list = []
-      array.each do |x|
-        list += x
-      end
-      list
-    end
-  end
-end

data/lib/nylas/categorize.rb

@@ -1,14 +0,0 @@
-# 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

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # An enumerable for working with index and search endpoints
-  class Collection
-    attr_accessor :model, :api, :constraints
-
-    extend Forwardable
-    def_delegators :each, :map, :select, :reject, :to_a, :take
-    def_delegators :to_a, :first, :last, :[]
-
-    def initialize(model:, api:, constraints: nil)
-      self.constraints = Constraints.from_constraints(constraints)
-      self.model = model
-      self.api = api
-    end
-
-    # Instantiates a new model
-    def new(**attributes)
-      model.new(**attributes.merge(api: api))
-    end
-
-    def create(**attributes)
-      instance = model.new(**attributes.merge(api: api))
-      instance.save
-      instance
-    end
-
-    # Merges in additional filters when querying the collection
-    # @return [Collection<Model>]
-    def where(filters)
-      raise ModelNotFilterableError, model unless model.filterable?
-
-      self.class.new(model: model, api: api, constraints: constraints.merge(where: filters))
-    end
-
-    def search(query)
-      raise ModelNotSearchableError, model unless model.searchable?
-
-      SearchCollection.new(model: model, api: api, constraints: constraints.merge(where: { q: query }))
-    end
-
-    # The collection now returns a string representation of the model in a particular mime type instead of
-    # Model objects
-    # @return [Collection<String>]
-    def raw
-      raise ModelNotAvailableAsRawError, model unless model.exposable_as_raw?
-
-      self.class.new(model: model, api: api, constraints: constraints.merge(accept: model.raw_mime_type))
-    end
-
-    # @return [Integer]
-    def count
-      collection = self.class.new(model: model, api: api, constraints: constraints)
-
-      if model.countable
-        collection.constraints = collection.constraints.merge(view: "count")
-        collection.execute[:count]
-      else
-        collection.find_each.map.count
-      end
-    end
-
-    # @return [Collection<Model>]
-    def expanded
-      self.class.new(model: model, api: api, constraints: constraints.merge(view: "expanded"))
-    end
-
-    # @return [Array<String>]
-    def ids
-      collection = self.class.new(model: model, api: api, constraints: constraints)
-
-      if model.id_listable
-        collection.constraints = collection.constraints.merge(view: "ids")
-        collection.execute
-      else
-        collection.find_each.map(&:id)
-      end
-    end
-
-    # Iterates over a single page of results based upon current pagination settings
-    def each
-      return enum_for(:each) unless block_given?
-
-      execute.each do |result|
-        yield(model.new(**result.merge(api: api)))
-      end
-    end
-
-    def limit(quantity)
-      self.class.new(model: model, api: api, constraints: constraints.merge(limit: quantity))
-    end
-
-    def offset(start)
-      self.class.new(model: model, api: api, constraints: constraints.merge(offset: start))
-    end
-
-    # Iterates over every result that meets the filters, retrieving a page at a time
-    def find_each
-      return enum_for(:find_each) unless block_given?
-
-      query = self
-      accumulated = 0
-
-      while query
-        results = query.each do |instance|
-          yield(instance)
-        end
-
-        accumulated += results.length
-        query = query.next_page(accumulated: accumulated, current_page: results)
-      end
-    end
-
-    def next_page(accumulated:, current_page:)
-      return nil unless more_pages?(accumulated, current_page)
-
-      self.class.new(model: model, api: api, constraints: constraints.next_page)
-    end
-
-    def more_pages?(accumulated, current_page)
-      return false if current_page.empty?
-      return false if constraints.limit && accumulated >= constraints.limit
-      return false if constraints.per_page && current_page.length < constraints.per_page
-
-      true
-    end
-
-    # Retrieves a record. Nylas doesn't support where filters on GET so this will not take into
-    # consideration other query constraints, such as where clauses.
-    def find(id)
-      constraints.accept == "application/json" ? find_model(id) : find_raw(id)
-    end
-
-    def find_raw(id)
-      api.execute(**to_be_executed.merge(path: "#{resources_path}/#{id}")).to_s
-    end
-
-    def resources_path
-      model.resources_path(api: api)
-    end
-
-    def find_model(id)
-      response = api.execute(
-        **to_be_executed.merge(
-          path: "#{resources_path}/#{id}",
-          query: view_query
-        )
-      )
-      model.from_hash(response, api: api)
-    end
-
-    # @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, auth_method: model.auth_method }
-    end
-
-    # Retrieves the data from the API for the particular constraints
-    # @return [Hash,Array]
-    def execute
-      api.execute(**to_be_executed)
-    end
-
-    private
-
-    def view_query
-      if constraints.view
-        { view: constraints.view }
-      else
-        {}
-      end
-    end
-  end
-end