nylas 5.17.0 → 6.0.3

data/lib/nylas/scheduler.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Ruby representation of a the Nylas Scheduler API
-  # @see https://developer.nylas.com/docs/api/scheduler/#overview
-  class Scheduler
-    include Model
-    self.resources_path = "/manage/pages"
-    self.creatable = true
-    self.listable = true
-    self.showable = true
-    self.filterable = true
-    self.updatable = true
-    self.destroyable = true
-
-    attribute :id, :integer, read_only: true
-    attribute :app_client_id, :string
-    attribute :app_organization_id, :integer
-    attribute :config, :scheduler_config
-    attribute :edit_token, :string
-    attribute :name, :string
-    attribute :slug, :string
-    attribute :created_at, :date
-    attribute :modified_at, :date
-
-    has_n_of_attribute :access_tokens, :string
-
-    def get_available_calendars
-      raise ArgumentError, "Cannot get calendars for a page without an ID." if id.nil?
-
-      api.execute(
-        method: :get,
-        path: "/manage/pages/#{id}/calendars"
-      )
-    end
-
-    def upload_image(content_type:, object_name:)
-      raise ArgumentError, "Cannot upload an image to a page without an ID." if id.nil?
-
-      payload = {
-        contentType: content_type,
-        objectName: object_name
-      }
-      api.execute(
-        method: :put,
-        path: "/manage/pages/#{id}/upload-image",
-        payload: JSON.dump(payload)
-      )
-    end
-  end
-end

data/lib/nylas/scheduler_booking_confirmation.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent the booking response returned from the Scheduler API
-  class SchedulerBookingConfirmation
-    include Model::Attributable
-    attribute :id, :integer
-    attribute :account_id, :string
-    attribute :calendar_event_id, :string
-    attribute :calendar_id, :string
-    attribute :edit_hash, :string
-    attribute :location, :string
-    attribute :title, :string
-    attribute :recipient_email, :string
-    attribute :recipient_locale, :string
-    attribute :recipient_name, :string
-    attribute :recipient_tz, :string
-    attribute :additional_field_values, :hash
-    attribute :is_confirmed, :boolean
-    attribute :start_time, :unix_timestamp
-    attribute :end_time, :unix_timestamp
-    has_n_of_attribute :additional_emails, :string
-  end
-end

data/lib/nylas/scheduler_booking_request.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent the booking request used for the Scheduler API
-  class SchedulerBookingRequest
-    include Model::Attributable
-    attribute :additional_values, :hash
-    attribute :email, :string
-    attribute :locale, :string
-    attribute :name, :string
-    attribute :page_hostname, :string
-    attribute :replaces_booking_hash, :string
-    attribute :timezone, :string
-    attribute :slot, :scheduler_time_slot
-    has_n_of_attribute :additional_emails, :string
-  end
-end

data/lib/nylas/scheduler_collection.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Additional methods for some of Scheduler's other functionality
-  # @see https://developer.nylas.com/docs/api/scheduler#overview
-  class SchedulerCollection < Collection
-    # Retrieve Google availability
-    # @return [Hash] Returns the availability
-    def get_google_availability
-      execute_provider_availability("google")
-    end
-
-    # Retrieve Office 365 availability
-    # @return [Hash] Returns the availability
-    def get_office_365_availability
-      execute_provider_availability("o365")
-    end
-
-    # Retrieve public config for a scheduling page
-    # @param slug [String] The Scheduler page slug
-    # @return [Scheduler] Returns the Scheduler object representing the page configuration
-    def get_page_slug(slug)
-      page_response = api.execute(
-        method: :get,
-        path: "/schedule/#{slug}/info"
-      )
-
-      Scheduler.new(**page_response.merge(api: api))
-    end
-
-    # Retrieve available time slots
-    # @param slug [String] The Scheduler page slug
-    # @return [Array<SchedulerTimeSlot>] Returns the list of available timeslots
-    def get_available_time_slots(slug)
-      response = api.execute(
-        method: :get,
-        path: "/schedule/#{slug}/timeslots"
-      )
-
-      timeslots = []
-      response.each do |available_slot|
-        timeslots.push(SchedulerTimeSlot.new(**available_slot.merge(api: api)))
-      end
-      timeslots
-    end
-
-    # Book a time slot
-    # @param slug [String] The Scheduler page slug
-    # @param timeslot [SchedulerBookingRequest] The time slot booking request
-    # @return [SchedulerBookingConfirmation] Returns the booking confirmation
-    def book_time_slot(slug, timeslot)
-      payload = timeslot.to_h
-      # The booking endpoint requires additional_values and additional_emails
-      # to exist regardless if they are empty or not
-      payload[:additional_values] = {} unless payload[:additional_values]
-      payload[:additional_emails] = [] unless payload[:additional_emails]
-      booking_response = api.execute(
-        method: :post,
-        path: "/schedule/#{slug}/timeslots",
-        payload: JSON.dump(payload)
-      )
-
-      SchedulerBookingConfirmation.new(**booking_response.merge(api: api))
-    end
-
-    # Cancel a booking
-    # @param slug [String] The Scheduler page slug
-    # @param edit_hash [String] The token used for editing the booked time slot
-    # @param reason [String] The reason for cancelling the booking
-    # @return [Hash] Returns a hash of a boolean representing success of cancellation
-    def cancel_booking(slug, edit_hash, reason)
-      api.execute(
-        method: :post,
-        path: "/schedule/#{slug}/#{edit_hash}/cancel",
-        payload: JSON.dump(reason: reason)
-      )
-    end
-
-    # Confirm a booking
-    # @param slug [String] The Scheduler page slug
-    # @param edit_hash [String] The token used for editing the booked time slot
-    # @return [SchedulerBookingConfirmation] Returns the confirmed booking confirmation
-    def confirm_booking(slug, edit_hash)
-      booking_response = api.execute(
-        method: :post,
-        path: "/schedule/#{slug}/#{edit_hash}/confirm",
-        payload: {}
-      )
-
-      SchedulerBookingConfirmation.new(**booking_response.merge(api: api))
-    end
-
-    private
-
-    # Retrieve provider availability
-    # @return [Hash] Returns the availability
-    def execute_provider_availability(provider)
-      api.execute(
-        method: :get,
-        path: "/schedule/availability/#{provider}"
-      )
-    end
-  end
-end

data/lib/nylas/scheduler_config.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Configuration settings for a Scheduler page
-  # @see https://developer.nylas.com/docs/api/scheduler
-  class SchedulerConfig
-    include Model::Attributable
-
-    attribute :appearance, :hash
-    attribute :booking, :hash
-    attribute :calendar_ids, :hash
-    attribute :event, :hash
-    attribute :expire_after, :hash
-    attribute :locale, :string
-    attribute :locale_for_guests, :string
-    attribute :timezone, :string
-
-    has_n_of_attribute :reminders, :hash
-  end
-end

data/lib/nylas/scheduler_time_slot.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent the time slot object from the Scheduler API
-  class SchedulerTimeSlot
-    include Model::Attributable
-    attribute :account_id, :string
-    attribute :calendar_id, :string
-    attribute :host_name, :string
-    attribute :start, :unix_timestamp
-    attribute :end, :unix_timestamp
-    has_n_of_attribute :emails, :string
-  end
-end

data/lib/nylas/search_collection.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Ensures our search requests hit the right path
-  class SearchCollection < Collection
-    def resources_path
-      "#{model.resources_path(api: api)}/search"
-    end
-  end
-end

data/lib/nylas/send_grid_verified_status.rb

@@ -1,12 +0,0 @@
-# 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/services/tunnel.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "faye/websocket"
-require "eventmachine"
-
-module Nylas
-  # Class containing methods to spin up a developmental websocket connection to test webhooks
-  class Tunnel
-    # Open a webhook tunnel and register it with the Nylas API
-    # 1. Creates a UUID
-    # 2. Opens a websocket connection to Nylas' webhook forwarding service, with the UUID as a header
-    # 3. Creates a new webhook pointed at the forwarding service with the UUID as the path
-    # When an event is received by the forwarding service, it will push directly to this websocket connection
-    #
-    # @param api [Nylas::API] The configured Nylas API client
-    # @param config [Hash] Configuration for the webhook tunnel, including callback functions, region, and
-    #   events to subscribe to
-    def self.open_webhook_tunnel(api, config = {})
-      tunnel_id = SecureRandom.uuid
-      triggers = config[:triggers] || WebhookTrigger.constants(false).map { |c| WebhookTrigger.const_get c }
-      region = config[:region] || "us"
-      websocket_domain = "tunnel.nylas.com"
-      callback_domain = "cb.nylas.com"
-
-      EM.run do
-        setup_websocket_client(websocket_domain, api, tunnel_id, region, config)
-        register_webhook_callback(api, callback_domain, tunnel_id, triggers)
-      end
-    end
-
-    # Register callback with the Nylas forwarding service which will pass messages to the websocket
-    # @param api [Nylas::API] The configured Nylas API client
-    # @param callback_domain [String] The domain name of the callback
-    # @param tunnel_path [String] The path to the tunnel
-    # @param triggers [Array<WebhookTrigger>] The list of triggers to subscribe to
-    # @return [Nylas::Webhook] The webhook details response from the API
-    def self.register_webhook_callback(api, callback_domain, tunnel_path, triggers)
-      callback_url = "https://#{callback_domain}/#{tunnel_path}"
-
-      api.webhooks.create(
-        callback_url: callback_url,
-        state: WebhookState::ACTIVE,
-        triggers: triggers
-      )
-    end
-
-    # Setup the websocket client and register the callbacks
-    # @param websocket_domain [String] The domain of the websocket to connect to
-    # @param api [Nylas::API] The configured Nylas API client
-    # @param tunnel_id [String] The ID of the tunnel
-    # @param region [String] The Nylas region to configure for
-    # @param config [Hash] The object containing all the callback methods
-    # @return [WebSocket::Client] The configured websocket client
-    def self.setup_websocket_client(websocket_domain, api, tunnel_id, region, config)
-      ws = Faye::WebSocket::Client.new(
-        "wss://#{websocket_domain}",
-        [],
-        {
-          headers: {
-            "Client-Id" => api.client.app_id,
-            "Client-Secret" => api.client.app_secret,
-            "Tunnel-Id" => tunnel_id,
-            "Region" => region
-          }
-        }
-      )
-
-      ws.on :open do |event|
-        config[:on_open].call(event) if callable(config[:on_open])
-      end
-
-      ws.on :close do |close|
-        config[:on_close].call(close) if callable(config[:on_close])
-        EM.stop
-      end
-
-      ws.on :error do |error|
-        config[:on_error].call(error) if callable(config[:on_error])
-      end
-
-      ws.on :message do |message|
-        deltas = parse_deltas_from_message(message)
-        next if deltas.nil?
-
-        deltas.each do |delta|
-          delta = merge_and_create_delta(delta)
-          config[:on_message].call(delta) if callable(config[:on_message])
-        end
-      end
-
-      ws
-    end
-
-    # Check if the object is a method
-    # @param obj [Any] The object to check
-    # @return [Boolean] True if the object is a method
-    def self.callable(obj)
-      !obj.nil? && obj.respond_to?(:call)
-    end
-
-    # Parse deltas from the message object
-    # @param message [Any] The message object containing the deltas
-    # @return [Hash] The parsed list of deltas
-    def self.parse_deltas_from_message(message)
-      return unless message.data
-
-      json = JSON.parse(message.data)
-      JSON.parse(json["body"])["deltas"]
-    end
-
-    # Clean up and create the delta object
-    # @param delta [Hash] The hash containing the delta attributes from the API
-    # @return [Nylas::Delta] The delta object
-    def self.merge_and_create_delta(delta)
-      object_data = delta.delete("object_data")
-      attributes = object_data.delete("attributes")
-      object_data["object_attributes"] = attributes
-      delta = delta.merge(object_data).transform_keys(&:to_sym)
-      Delta.new(**delta)
-    end
-
-    private_class_method :setup_websocket_client,
-                         :callable,
-                         :parse_deltas_from_message,
-                         :merge_and_create_delta
-  end
-end

data/lib/nylas/thread.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Ruby representation of the Nylas /threads API
-  # @see https://docs.nylas.com/reference#threads
-  class Thread
-    include Model
-    self.searchable = true
-    self.listable = true
-    self.filterable = true
-    self.updatable = true
-    self.id_listable = true
-    self.countable = true
-
-    self.resources_path = "/threads"
-
-    attribute :id, :string
-    attribute :object, :string
-    attribute :account_id, :string
-    has_n_of_attribute :draft_ids, :string
-    attribute :first_message_timestamp, :unix_timestamp
-    attribute :has_attachments, :boolean
-
-    attribute :last_message_timestamp, :unix_timestamp
-    attribute :last_message_received_timestamp, :unix_timestamp
-    attribute :last_message_sent_timestamp, :unix_timestamp
-
-    has_n_of_attribute :labels, :label
-    has_n_of_attribute :folders, :folder
-    has_n_of_attribute :message_ids, :string
-    has_n_of_attribute :messages, :message
-    has_n_of_attribute :participants, :participant
-    attribute :snippet, :string
-    attribute :starred, :boolean
-    attribute :subject, :string
-    attribute :unread, :boolean
-    attribute :version, :integer
-    attribute :folder_id, :string
-
-    has_n_of_attribute :label_ids, :string
-
-    transfer :api, to: %i[labels folders]
-
-    UPDATABLE_ATTRIBUTES = %i[label_ids folder_id starred unread].freeze
-    def update(data)
-      unupdatable_attributes = data.keys.reject { |name| UPDATABLE_ATTRIBUTES.include?(name) }
-      unless unupdatable_attributes.empty?
-        raise ArgumentError, "Cannot update #{unupdatable_attributes} only " \
-                             "#{UPDATABLE_ATTRIBUTES} are updatable"
-      end
-      super(**data)
-    end
-
-    def update_folder(folder_id)
-      update(folder_id: folder_id)
-    end
-
-    def starred?
-      starred
-    end
-
-    def unread?
-      unread
-    end
-  end
-end

data/lib/nylas/time_slot.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Query free/busy information for a calendar during a certain time period
-  # @see https://docs.nylas.com/reference#calendars-free-busy
-  class TimeSlot
-    include Model::Attributable
-
-    attribute :object, :string
-    attribute :status, :string
-    attribute :start_time, :unix_timestamp
-    attribute :end_time, :unix_timestamp
-    attribute :capacity, :time_slot_capacity
-    has_n_of_attribute :emails, :string
-  end
-end

data/lib/nylas/time_slot_capacity.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Capacity values for a timeslot
-  # @see https://docs.nylas.com/reference#calendars-free-busy
-  class TimeSlotCapacity
-    include Model::Attributable
-
-    attribute :event_id, :string
-    attribute :current_capacity, :integer
-    attribute :max_capacity, :integer
-  end
-end

data/lib/nylas/timespan.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent a Nylas Timespan.
-  # @see https://docs.nylas.com/reference#section-timespan
-  class Timespan
-    extend Forwardable
-
-    include Model::Attributable
-    attribute :object, :string
-    attribute :start_time, :unix_timestamp
-    attribute :end_time, :unix_timestamp
-
-    def_delegators :range, :cover?
-
-    def range
-      @range ||= Range.new(start_time, end_time)
-    end
-  end
-end

data/lib/nylas/token_info.rb

@@ -1,20 +0,0 @@
-# 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/types.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Collection of attribute types
-  module Types
-    def self.registry
-      @registry ||= Registry.new
-    end
-
-    # Base type for attributes
-    class ValueType
-      def cast(object)
-        object
-      end
-
-      def serialize(object)
-        object
-      end
-
-      def deseralize(object)
-        object
-      end
-
-      def serialize_for_api(object)
-        serialize(object)
-      end
-    end
-
-    # Casts/Serializes data that is persisted and used natively as a Hash
-    class HashType < ValueType
-      def serialize(object)
-        object.to_h
-      end
-
-      def cast(value)
-        return JSON.parse(value, symbolize_names: true) if value.is_a?(String)
-        return value if value.respond_to?(:key)
-      end
-    end
-    Types.registry[:hash] = HashType.new
-
-    # Type for attributes that are persisted in the API as a hash but exposed in ruby as a particular
-    # {Model} or Model-like thing.
-    class ModelType < ValueType
-      attr_accessor :model
-
-      def initialize(model:)
-        super()
-        self.model = model
-      end
-
-      def serialize(object)
-        object.to_h
-      end
-
-      def serialize_for_api(object)
-        object&.to_h(enforce_read_only: true)
-      end
-
-      def cast(value)
-        return model.new if value.nil?
-        return value if already_cast?(value)
-        return model.new(**actual_attributes(value)) if value.respond_to?(:key?)
-
-        raise TypeError, "Unable to cast #{value} to a #{model}"
-      end
-
-      def already_cast?(value)
-        model.attribute_definitions.keys.all? { |attribute_name| value.respond_to?(attribute_name) }
-      end
-
-      def actual_attributes(hash)
-        model.attribute_definitions.keys.each_with_object({}) do |attribute_name, attributes|
-          attributes[attribute_name] = hash[json_key_from_attribute_name(attribute_name)]
-        end
-      end
-
-      def json_key_from_attribute_name(name)
-        name
-      end
-    end
-
-    # Type for attributes represented as a unix timestamp in the API and Time in Ruby
-    class UnixTimestampType < ValueType
-      def cast(object)
-        return object if object.is_a?(Time) || object.nil?
-        return Time.at(object.to_i) if object.is_a?(String)
-        return Time.at(object) if object.is_a?(Numeric)
-        return object.to_time if object.is_a?(Date)
-
-        raise TypeError, "Unable to cast #{object} to Time"
-      end
-
-      def deserialize(object)
-        cast(object)
-      end
-
-      def serialize(object)
-        return nil if object.nil?
-
-        object.to_i
-      end
-    end
-    Types.registry[:unix_timestamp] = UnixTimestampType.new
-
-    # Type for attributes represented as an iso8601 dates in the API and Date in Ruby
-    class DateType < ValueType
-      def cast(value)
-        return nil if value.nil?
-
-        Date.parse(value)
-      end
-
-      def serialize(value)
-        return value.iso8601 if value.respond_to?(:iso8601)
-
-        value
-      end
-    end
-    Types.registry[:date] = DateType.new
-
-    # Type for attributes represented as pure strings both within the API and in Ruby
-    class StringType < ValueType
-      # @param value [Object] Casts the passed in object to a string using #to_s
-      def cast(value)
-        return value if value.nil?
-
-        value.to_s
-      end
-    end
-    Types.registry[:string] = StringType.new
-
-    # Type for attributes represented as pure integers both within the API and in Ruby
-    class IntegerType < ValueType
-      # @param value [Object] Casts the passed in object to an integer using to_i
-      def cast(value)
-        return nil if value.nil?
-
-        value.to_i
-      end
-    end
-    Types.registry[:integer] = IntegerType.new
-
-    # Type for attributes represented as booleans.
-    class BooleanType < ValueType
-      # @param value [Object] Strictly casts the passed in value to a boolean (must be true, not "" or 1)
-      def cast(value)
-        return nil if value.nil?
-        return true if value == true
-        return false if value == false
-
-        raise TypeError, "#{value} must be either true or false"
-      end
-    end
-    Types.registry[:boolean] = BooleanType.new
-
-    # Type for attributes represented as floats.
-    class FloatType < ValueType
-      # @param value [Object] Strictly casts the passed in value to a boolean (must be true, not "" or 1)
-      def cast(value)
-        return nil if value.nil?
-
-        value.to_f
-      end
-    end
-    Types.registry[:float] = FloatType.new
-  end
-end