nylas_v2 5.14.2

data/lib/nylas_v2/collection.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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

data/lib/nylas_v2/component.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Structure to represent a the Component Schema.
+  class Component
+    include Model
+    self.creatable = true
+    self.listable = true
+    self.showable = true
+    self.filterable = true
+    self.updatable = true
+    self.destroyable = true
+    self.auth_method = HttpClient::AuthMethod::BASIC
+
+    attribute :id, :string, read_only: true
+    attribute :account_id, :string
+    attribute :name, :string
+    attribute :type, :string
+    attribute :action, :integer
+    attribute :active, :boolean
+    attribute :settings, :hash
+    attribute :public_account_id, :string
+    attribute :public_token_id, :string
+    attribute :public_application_id, :string, read_only: true
+    attribute :access_token, :string
+    attribute :created_at, :date, read_only: true
+    attribute :updated_at, :date, read_only: true
+
+    has_n_of_attribute :allowed_domains, :string
+
+    def resources_path(*)
+      "/component/#{api.client.app_id}"
+    end
+  end
+end

data/lib/nylas_v2/component_collection.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Additional configuration for the Component CRUD API
+  class ComponentCollection < Collection
+    def resources_path
+      "/component/#{api.client.app_id}"
+    end
+  end
+end

data/lib/nylas_v2/constraints.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # The constraints a particular GET request will include in their query params
+  class Constraints
+    attr_accessor :where, :limit, :offset, :view, :per_page, :accept
+
+    def initialize(where: {}, limit: nil, offset: 0, view: nil, per_page: 100, accept: "application/json")
+      self.where = where
+      self.limit = limit
+      self.offset = offset
+      self.view = view
+      self.per_page = per_page
+      self.accept = accept
+    end
+
+    def merge(where: {}, limit: nil, offset: nil, view: nil, per_page: nil, accept: nil)
+      Constraints.new(where: self.where.merge(where),
+                      limit: limit || self.limit,
+                      per_page: per_page || self.per_page,
+                      offset: offset || self.offset,
+                      view: view || self.view,
+                      accept: accept || self.accept)
+    end
+
+    def next_page
+      merge(offset: offset + per_page)
+    end
+
+    def to_query
+      query = where.each_with_object({}) do |(name, value), result|
+        result[name] = value
+      end
+      query[:limit] = limit_for_query
+      query[:offset] = offset unless offset.nil?
+      query[:view] = view unless view.nil?
+      query
+    end
+
+    def to_headers
+      accept == "application/json" ? {} : { "Accept" => accept, "Content-types" => accept }
+    end
+
+    def limit_for_query
+      !limit.nil? && limit < per_page ? limit : per_page
+    end
+
+    def self.from_constraints(constraints = Constraints.new)
+      return constraints if constraints.is_a?(Constraints)
+      return new(**constraints) if constraints.respond_to?(:key?)
+      return new if constraints.nil?
+
+      raise TypeError, "passed in constraints #{constraints} cannot be cast to a set of constraints"
+    end
+  end
+end

data/lib/nylas_v2/contact.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # ActiveModel compliant interface for interacting with the Contacts API
+  # @see https://docs.nylas.com/reference#contacts
+  class Contact
+    include Model
+    self.resources_path = "/contacts"
+    self.creatable = true
+    self.listable = true
+    self.showable = true
+    self.filterable = true
+    self.updatable = true
+    self.destroyable = true
+
+    attribute :id, :string, read_only: true
+    attribute :object, :string, default: "contact"
+    attribute :account_id, :string, read_only: true
+
+    attribute :given_name, :string
+    attribute :middle_name, :string
+    attribute :picture_url, :string
+    attribute :surname, :string
+    attribute :birthday, :string
+    attribute :suffix, :string
+    attribute :nickname, :string
+    attribute :company_name, :string
+    attribute :job_title, :string
+    attribute :manager_name, :string
+    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
+    has_n_of_attribute :im_addresses, :im_address
+    has_n_of_attribute :physical_addresses, :physical_address
+    has_n_of_attribute :phone_numbers, :phone_number
+    has_n_of_attribute :web_pages, :web_page
+
+    # @returns [Tempfile] path to the retrieved picture. It is preferrable to cache this in your system than
+    # to retrieve it from nylas every time.
+    def picture
+      return @picture_tempfile if @picture_tempfile
+
+      @picture_tempfile = Tempfile.new
+      @picture_tempfile.write(api.get(path: "#{resource_path}/picture"))
+      @picture_tempfile.close
+      @picture_tempfile
+    end
+  end
+end

data/lib/nylas_v2/contact_group.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Structure to represent the Contact Group schema
+  # @see https://docs.nylas.com/reference#contactsid
+  class ContactGroup
+    include Model
+    self.resources_path = "/contacts/groups"
+
+    self.creatable = false
+    self.destroyable = false
+    self.filterable = false
+    self.listable = true
+    self.showable = false
+    self.updatable = false
+
+    attribute :id, :string
+    attribute :object, :string
+    attribute :account_id, :string
+    attribute :name, :string
+    attribute :path, :string
+  end
+end

data/lib/nylas_v2/current_account.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Ruby representation of the Nylas /account API
+  # @see https://docs.nylas.com/reference#account
+  class CurrentAccount
+    include Model
+    self.showable = true
+
+    self.resources_path = "/account"
+
+    attribute :id, :string
+    attribute :object, :string, default: "account"
+
+    attribute :account_id, :string
+    attribute :email_address, :string
+    attribute :name, :string
+    attribute :organization_unit, :string
+    attribute :provider, :string
+    attribute :sync_state, :string
+    attribute :linked_at, :unix_timestamp
+  end
+end

data/lib/nylas_v2/delta.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Ruby object to represent a single change. Used both when receiving a webhook, as well as the deltas API.
+  # @see https://docs.nylas.com/reference#receiving-notifications
+  # @see https://docs.nylas.com/reference#deltas
+  class Delta
+    include Model::Attributable
+
+    attribute :id, :string
+    attribute :type, :string
+    attribute :object, :string
+    attribute :event, :string
+    attribute :cursor, :string
+    attribute :namespace_id, :string
+    attribute :account_id, :string
+
+    attribute :headers, :message_headers
+
+    attribute :date, :unix_timestamp
+    attribute :metadata, :hash
+    attribute :object_attributes, :hash
+
+    def model
+      return nil if object.nil?
+
+      @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
+  end
+
+  # Casts Delta data from either a webhook or a delta stream to a Delta
+  class DeltaType < Types::ModelType
+    def initialize
+      super(model: Delta)
+    end
+
+    def cast(data)
+      data = if data.key?(:object_data)
+               object_data = data.delete(:object_data)
+               data.merge(object_data)
+             else
+               data
+             end
+
+      data = data.merge(data[:attributes]) if data[:attributes]
+      data[:object_attributes] = data.delete(:attributes)
+      super(**data)
+    end
+  end
+end

data/lib/nylas_v2/deltas.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Ruby object to represent a collection of changes. Used both when receiving a webhook, as well as the
+  # deltas API.
+  # @see https://docs.nylas.com/reference#receiving-notifications
+  # @see https://docs.nylas.com/reference#deltas
+  class Deltas
+    include Model
+    self.resources_path = "/delta"
+    self.filterable = true
+    has_n_of_attribute :deltas, :delta
+    attribute :cursor_start, :string
+    attribute :cursor_end, :string
+
+    extend Forwardable
+    def_delegators :deltas, :count, :length, :each, :map, :first, :last, :to_a, :empty?
+  end
+end

data/lib/nylas_v2/deltas_collection.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Special collection for delta objects
+  class DeltasCollection < Collection
+    attr_accessor :deltas
+
+    extend Forwardable
+    def_delegators :execute, :cursor_start, :cursor_end,
+                   :count, :each, :to_h, :to_a, :empty?
+
+    def initialize(api:, constraints: nil, model: Deltas)
+      super(api: api, model: model, constraints: constraints)
+    end
+
+    def latest_cursor
+      api.execute(method: :post, path: "#{resources_path}/latest_cursor")[:cursor]
+    end
+
+    def latest
+      since(latest_cursor)
+    end
+
+    def since(cursor)
+      where(cursor: cursor)
+    end
+
+    def next_page(*)
+      return nil if empty?
+
+      where(cursor: cursor_end)
+    end
+
+    # Retrieves the data from the API for the particular constraints
+    # @return [Detlas]
+    def execute
+      self.deltas ||= Deltas.new(**api.execute(**to_be_executed))
+    end
+  end
+end

data/lib/nylas_v2/draft.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Ruby representatin of a Nylas Draft object
+  # @see https://docs.nylas.com/reference#drafts
+  class Draft
+    include Model
+    self.resources_path = "/drafts"
+    self.creatable = true
+    self.listable = true
+    self.showable = true
+    self.updatable = true
+    self.destroyable = true
+    self.id_listable = true
+    self.countable = true
+
+    attribute :id, :string
+    attribute :object, :string
+    attribute :version, :integer
+    attribute :account_id, :string
+    attribute :thread_id, :string
+    attribute :reply_to_message_id, :string
+
+    has_n_of_attribute :to, :email_address
+    has_n_of_attribute :from, :email_address
+    has_n_of_attribute :cc, :email_address
+    has_n_of_attribute :bcc, :email_address
+    has_n_of_attribute :reply_to, :email_address
+
+    attribute :date, :unix_timestamp
+    attribute :subject, :string
+    attribute :snippet, :string
+    attribute :body, :string
+    attribute :starred, :boolean
+    attribute :unread, :boolean
+    attribute :metadata, :hash
+
+    has_n_of_attribute :events, :event
+    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
+
+    attribute :tracking, :message_tracking
+    attribute :job_status_id, :string, read_only: true
+
+    transfer :api, to: %i[events files folder labels]
+
+    def update(**data)
+      # If files are provided, replace files with file IDs
+      self.files = data[:files] if data[:files]
+      extract_file_ids!
+      data[:file_ids] = file_ids
+      # If version is not provided, add version or request will fail
+      data[:version] = version unless data[:version]
+
+      super
+    end
+
+    def create
+      extract_file_ids!
+
+      super
+    end
+
+    def send!
+      return execute(method: :post, path: "/send", payload: to_json) unless id
+
+      data = { draft_id: id, version: version }
+      data[:tracking] = tracking.to_h if tracking
+      execute(method: :post, path: "/send", payload: JSON.dump(data))
+    end
+
+    def starred?
+      starred
+    end
+
+    def unread?
+      unread
+    end
+
+    def destroy
+      execute(method: :delete, path: resource_path, payload: attributes.serialize_for_api(keys: [:version]))
+    end
+
+    def save
+      extract_file_ids!
+
+      super
+    end
+
+    private
+
+    def extract_file_ids!
+      files = self.files || []
+
+      self.file_ids ||= files.map(&:id)
+    end
+  end
+end

data/lib/nylas_v2/email_address.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Structure to represent the Email Address Schema
+  # @see https://docs.nylas.com/reference#contactsid
+  class EmailAddress
+    include Model::Attributable
+    attribute :type, :string
+    attribute :email, :string
+    attribute :name, :string
+  end
+end