nylas-legacy 5.17.0 → 5.18.0

data/lib/nylas-legacy/scheduler_collection.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/scheduler_config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/scheduler_time_slot.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/search_collection.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # Ensures our search requests hit the right path
+  class SearchCollection < Collection
+    def resources_path
+      "#{model.resources_path(api: api)}/search"
+    end
+
+    def count
+      self.class.new(model: model, api: api, constraints: constraints).find_each.map.count
+    end
+  end
+end

data/lib/nylas-legacy/send_grid_verified_status.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/services/tunnel.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "faye/websocket"
+require "eventmachine"
+
+module NylasLegacy
+  # 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 [NylasLegacy::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 [NylasLegacy::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 [NylasLegacy::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 [NylasLegacy::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 [NylasLegacy::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-legacy/thread.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/time_slot.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/time_slot_capacity.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/timespan.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/token_info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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-legacy/types.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # 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)
+
+        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

data/lib/nylas-legacy/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  VERSION = "5.18.0"
+end

data/lib/nylas-legacy/web_page.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module NylasLegacy
+  # Structure to represent the Web Page Schema
+  # @see https://docs.nylas.com/reference#contactsid
+  class WebPage
+    include Model::Attributable
+    attribute :type, :string
+    attribute :url, :string
+  end
+end