calendlyr 0.7.5 → 1.0.0

data/lib/calendlyr/error.rb

@@ -1,54 +1,92 @@
 module Calendlyr
-  class Error < StandardError; end
-
-  class PermissionDenied < StandardError; end
-
-  class BadRequest < StandardError; end
-
-  class PaymentRequired < StandardError; end
+  class Error < StandardError
+    attr_reader :status, :http_method, :path, :response_body
+
+    def initialize(message = nil, status: nil, http_method: nil, path: nil, response_body: nil)
+      @status = status
+      @http_method = http_method
+      @path = path
+      @response_body = response_body
+      super(message)
+    end
+  end
 
-  class Unauthenticated < StandardError; end
+  class WebhookSignatureError < Error; end
 
-  class NotFound < StandardError; end
+  class WebhookTimestampError < Error; end
 
-  class ExternalCalendarError < StandardError; end
+  class PaymentRequired < Error; end
 
-  class InternalServerError < StandardError; end
+  ERROR_TYPES = {
+    "400" => "BadRequest",
+    "401" => "Unauthenticated",
+    "403" => "PermissionDenied",
+    "404" => "NotFound",
+    "424" => "ExternalCalendarError",
+    "429" => "TooManyRequests",
+    "500" => "InternalServerError"
+  }
 
-  class TooManyRequests < StandardError; end
+  ERROR_TYPES.values.each do |error_class|
+    Calendlyr.const_set(error_class, Class.new(Error))
+  end
 
   class ResponseErrorHandler
-    ERROR_TYPES = {
-      "400" => BadRequest,
-      "401" => Unauthenticated,
-      "403" => PermissionDenied,
-      "404" => NotFound,
-      "424" => ExternalCalendarError,
-      "429" => TooManyRequests,
-      "500" => InternalServerError
-    }
-
-    def initialize(code, body)
+    def initialize(code, body, method: nil, path: nil)
       @code = code
       @body = body
+      @method = method
+      @path = path
     end
 
     def error
       return too_many_requests_error if @code == "429"
 
-      error_type.new("[Error #{@code}] #{@body["title"]}. #{@body["message"]}")
+      error_type.new(
+        message,
+        status: @code,
+        http_method: @method,
+        path: @path,
+        response_body: @body
+      )
     end
 
     private
 
     def error_type
-      return PaymentRequired if @code == "403" && @body["message"].include?("upgrade")
+      return PaymentRequired if @code == "403" && @body.fetch("message", "").include?("upgrade")
 
-      ERROR_TYPES[@code]
+      klass = "Calendlyr::#{Calendlyr::ERROR_TYPES[@code]}"
+      Calendlyr.const_get(klass)
     end
 
     def too_many_requests_error
-      error_type.new("[Error #{@code}] Too many requests, please try again later.")
+      error_type.new(
+        contextual_message("Too many requests, please try again later."),
+        status: @code,
+        http_method: @method,
+        path: @path,
+        response_body: @body
+      )
+    end
+
+    def message
+      contextual_message(body_message)
+    end
+
+    def body_message
+      [@body["title"], @body["message"]].compact.reject(&:empty?).join(". ")
+    end
+
+    def contextual_message(body_message)
+      base = "[Error #{@code}]"
+      return [base, body_message].reject(&:empty?).join(" ") unless @method && @path
+
+      path = @path.start_with?("/") ? @path : "/#{@path}"
+      context = "#{@method} #{path}"
+      return "#{base} #{context}" if body_message.empty?
+
+      "#{base} #{context} — #{body_message}"
     end
   end
 end

data/lib/calendlyr/object.rb

@@ -1,31 +1,103 @@
-require "ostruct"
+require "json"
 
 module Calendlyr
-  class Object < OpenStruct
+  class Object
+    FILTERED_KEYS = %w[client].freeze
+    private_constant :FILTERED_KEYS
+
     def self.get_slug(path)
       path.split("/").last
     end
 
-    def initialize(attributes)
-      super(to_ostruct(attributes.merge(uuid: extract_uuid(attributes))))
+    private_class_method :get_slug
+
+    def initialize(attributes = nil, add_uuid: true, **kwargs)
+      attrs = (attributes || {}).merge(kwargs).dup
+      if add_uuid && !attrs.key?(:uuid) && !attrs.key?("uuid")
+        attrs = attrs.merge(uuid: extract_uuid(attrs))
+      end
+
+      @attributes = attrs.each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = wrap(value)
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if args.empty? && block.nil?
+        return @attributes[name.to_s] if @attributes.key?(name.to_s)
+
+        return nil
+      end
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @attributes.key?(name.to_s) || super
     end
 
-    def to_ostruct(obj)
-      if obj.is_a?(Hash)
-        OpenStruct.new(obj.map { |key, val| [key, to_ostruct(val)] }.to_h)
-      elsif obj.is_a?(Array)
-        obj.map { |o| to_ostruct(o) }
-      else # Assumed to be a primitive value
-        obj
+    def to_h
+      @attributes.except(*FILTERED_KEYS).each_with_object({}) do |(key, value), hash|
+        hash[key.to_sym] = unwrap(value)
       end
     end
 
+    def to_json(*)
+      to_h.to_json(*)
+    end
+
+    def inspect
+      attributes = @attributes.map do |key, value|
+        "#{key}=#{value.inspect}"
+      end.join(" ")
+      "#<#{self.class} #{attributes}>"
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && to_h == other.to_h
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      to_h.hash
+    end
+
+    private
+
     def extract_uuid(attrs)
-      attrs["uri"] ? get_slug(attrs["uri"]) : nil
+      uri = attrs["uri"] || attrs[:uri]
+      uri ? get_slug(uri) : nil
     end
 
+    protected
+
     def get_slug(path)
-      Calendlyr::Object.get_slug(path)
+      self.class.send(:get_slug, path)
+    end
+
+    private
+
+    def wrap(value)
+      if value.is_a?(Hash)
+        self.class.new(value, add_uuid: false)
+      elsif value.is_a?(Array)
+        value.map { |item| wrap(item) }
+      else
+        value
+      end
+    end
+
+    def unwrap(value)
+      if value.is_a?(self.class)
+        value.to_h
+      elsif value.is_a?(Array)
+        value.map { |item| unwrap(item) }
+      else
+        value
+      end
     end
   end
 end

data/lib/calendlyr/objects/event_type.rb

@@ -7,9 +7,5 @@ module Calendlyr
     def create_share(**params)
       client.shares.create(**params.merge(event_type: uri))
     end
-
-    def available_times(start_time:, end_time:, **params)
-      client.event_types.list_available_times(**params.merge(event_type: uri, start_time: start_time, end_time: end_time))
-    end
   end
 end

data/lib/calendlyr/objects/event_types/availability_schedule.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Calendlyr
+  module EventTypes
+    class AvailabilitySchedule < Object
+    end
+  end
+end

data/lib/calendlyr/objects/event_types/available_time.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module Calendlyr
-  class EventTypes::AvailableTime < Object
+  module EventTypes
+    class AvailableTime < Object
+    end
   end
 end

data/lib/calendlyr/objects/event_types/membership.rb

@@ -1,11 +1,8 @@
-module Calendlyr
-  class EventTypes::Membership < Object
-    def associated_event_type
-      client.event_types.retrieve(uuid: get_slug(event_type.uri))
-    end
+# frozen_string_literal: true
 
-    def associated_member
-      client.users.retrieve(uuid: get_slug(member.uri))
+module Calendlyr
+  module EventTypes
+    class Membership < Object
     end
   end
 end

data/lib/calendlyr/objects/events/invitee.rb

@@ -1,7 +1,7 @@
 module Calendlyr
   class Events::Invitee < Object
     def cancel(reason: nil)
-      client.events.cancel(uuid: uuid, reason: reason)
+      client.events.cancel(uuid: get_slug(event), reason: reason)
     end
 
     def create_no_shows

data/lib/calendlyr/objects/location.rb

@@ -0,0 +1,4 @@
+module Calendlyr
+  class Location < Object
+  end
+end

data/lib/calendlyr/objects/organization.rb

@@ -43,10 +43,6 @@ module Calendlyr
       client.webhooks.create(**params.merge(organization: uri, url: url, events: events, scope: scope))
     end
 
-    def sample_webhook_data(event:, scope:, **params)
-      client.webhooks.sample_webhook_data(event: event, scope: scope, organization: uri, **params)
-    end
-
     # Invitations
     def invite_user(email:, **params)
       client.organizations.invite(**params.merge(organization_uuid: uuid, email: email))

data/lib/calendlyr/objects/outgoing_communication.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Calendlyr
+  class OutgoingCommunication < Object
+  end
+end

data/lib/calendlyr/objects/scheduling_link.rb

@@ -1,9 +1,6 @@
+# frozen_string_literal: true
+
 module Calendlyr
   class SchedulingLink < Object
-    def event_type
-      return unless owner_type == "EventType"
-
-      client.event_types.retrieve(uuid: get_slug(owner))
-    end
   end
 end

data/lib/calendlyr/objects/share.rb

@@ -1,9 +1,4 @@
 module Calendlyr
   class Share < Object
-    def associated_scheduling_links
-      scheduling_links.map do |scheduling_link|
-        SchedulingLink.new(scheduling_link.to_h.merge(client: client))
-      end
-    end
   end
 end

data/lib/calendlyr/objects/webhooks/payload.rb

@@ -1,4 +1,34 @@
 module Calendlyr
   class Webhooks::Payload < Object
+    INVITEE_EVENTS = %w[
+      invitee.created
+      invitee.canceled
+      invitee_no_show.created
+      invitee_no_show.deleted
+    ].freeze
+
+    def initialize(attributes = nil, add_uuid: true, **kwargs)
+      attrs = (attributes || {}).merge(kwargs)
+      attrs = attrs.merge("payload" => payload_object(attrs))
+
+      super(attrs, add_uuid: add_uuid)
+    end
+
+    private
+
+    def payload_object(attrs)
+      payload = attrs["payload"] || attrs[:payload]
+      return payload unless payload.is_a?(Hash)
+
+      return Webhooks::InviteePayload.new(payload, add_uuid: false) if INVITEE_EVENTS.include?(attrs["event"] || attrs[:event])
+
+      payload
+    end
+
+    def wrap(value)
+      return value unless value.is_a?(Hash)
+
+      Calendlyr::Object.new(value, add_uuid: false)
+    end
   end
 end

data/lib/calendlyr/resource.rb

@@ -8,6 +8,8 @@ module Calendlyr
     attr_reader :client
 
     ERROR_CODES = %w[400 401 403 404 424 429 500]
+    MAX_RETRIES = 3
+    RETRY_BACKOFF = [1, 2, 4]
 
     def initialize(client)
       @client = client
@@ -16,15 +18,23 @@ module Calendlyr
     private
 
     def get_request(url, params: {})
-      handle_response request(url, Net::HTTP::Get, params: params)
+      handle_response request(url, Net::HTTP::Get, params: params), method: "GET", path: url
     end
 
     def post_request(url, body:)
-      handle_response request(url, Net::HTTP::Post, body: body)
+      handle_response request(url, Net::HTTP::Post, body: body), method: "POST", path: url
+    end
+
+    def patch_request(url, body:)
+      handle_response request(url, Net::HTTP::Patch, body: body), method: "PATCH", path: url
+    end
+
+    def put_request(url, body:)
+      handle_response request(url, Net::HTTP::Put, body: body), method: "PUT", path: url
     end
 
     def delete_request(url, params: {})
-      handle_response request(url, Net::HTTP::Delete, params: params)
+      handle_response request(url, Net::HTTP::Delete, params: params), method: "DELETE", path: url
     end
 
     def request(url, req_type, body: {}, params: {}, base_url: Client::BASE_URL)
@@ -37,30 +47,92 @@ module Calendlyr
 
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http.open_timeout = client.open_timeout
+      http.read_timeout = client.read_timeout
 
       request = req_type.new(uri)
       request["Content-Type"] = "application/json"
       request["Authorization"] = "Bearer #{client.token}"
       request.body = body.to_json if body.any?
 
-      http.request(request)
+      logging_enabled = !logger.nil?
+      start_time = monotonic_now if logging_enabled
+      request_method = request.method
+      request_url = uri.to_s if logging_enabled
+      attempts = 0
+      response = nil
+
+      loop do
+        response = http.request(request)
+        break unless response.code == "429"
+        break if attempts >= MAX_RETRIES
+
+        backoff_seconds = retry_after_seconds(response, attempts)
+        log(:warn, "retry_attempt=#{attempts + 1} method=#{request_method} url=#{request_url} status=429 backoff_seconds=#{backoff_seconds}")
+        sleep backoff_seconds
+        attempts += 1
+      end
+
+      if logging_enabled
+        log(:info, "method=#{request_method} url=#{request_url} status=#{response.code} duration_ms=#{elapsed_milliseconds(start_time)}")
+        log(:debug, "response_body=#{truncated_body(response.body.to_s)}")
+      end
+
+      response
     end
 
-    def handle_response(response)
-      return true unless response.read_body
+    def handle_response(response, method: nil, path: nil)
+      body_string = response.body.to_s
 
       body = begin
-        JSON.parse(response.read_body)
-      rescue
+        body_string.empty? ? {} : JSON.parse(body_string)
+      rescue JSON::ParserError
         {}
       end
 
       if ERROR_CODES.include? response.code
-        raise ResponseErrorHandler.new(response.code, body).error
-      else
-        body
+        log(:error, "method=#{method} path=/#{path} status=#{response.code} response_body=#{truncated_body(body_string)}")
+        raise ResponseErrorHandler.new(response.code, body, method: method, path: path).error
       end
+
+      body
+    end
+
+    def retry_after_seconds(response, attempt)
+      retry_after = response["Retry-After"]
+      return retry_after.to_i if retry_after&.match?(/^\d+$/)
+
+      RETRY_BACKOFF.fetch(attempt)
+    end
+
+    def expand_uri(value, resource_type)
+      return value if value.nil? || value.start_with?("https://")
+
+      "#{Client::BASE_URL}/#{resource_type}/#{value}"
+    end
+
+    def logger
+      client.logger
+    end
+
+    def log(level, message)
+      return unless logger
+
+      logger.public_send(level, "[calendlyr] #{message}")
+    end
+
+    def truncated_body(body_string)
+      return body_string if body_string.length <= 1000
+
+      "#{body_string[0, 1000]}... (truncated)"
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def elapsed_milliseconds(start_time)
+      ((monotonic_now - start_time) * 1000).round(1)
     end
   end
 end

data/lib/calendlyr/resources/availability.rb

@@ -2,14 +2,26 @@ module Calendlyr
   class AvailabilityResource < Resource
     # User Busy Time
     def list_user_busy_times(user:, start_time:, end_time:, **params)
+      next_page_caller = ->(page_token:) { list_user_busy_times(user: user, start_time: start_time, end_time: end_time, **params, page_token: page_token) }
+      user = expand_uri(user, "users")
       response = get_request("user_busy_times", params: {user: user, start_time: start_time, end_time: end_time}.merge(params).compact)
-      Collection.from_response(response, type: Availabilities::UserBusyTime, client: client)
+      Collection.from_response(response, type: Availabilities::UserBusyTime, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_user_busy_times(user:, start_time:, end_time:, **params)
+      list_user_busy_times(user: user, start_time: start_time, end_time: end_time, **params).auto_paginate.to_a
     end
 
     # User Schedule
     def list_user_schedules(user:, **params)
+      next_page_caller = ->(page_token:) { list_user_schedules(user: user, **params, page_token: page_token) }
+      user = expand_uri(user, "users")
       response = get_request("user_availability_schedules", params: {user: user}.merge(params).compact)
-      Collection.from_response(response, type: Availabilities::UserSchedule, client: client)
+      Collection.from_response(response, type: Availabilities::UserSchedule, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_user_schedules(user:, **params)
+      list_user_schedules(user: user, **params).auto_paginate.to_a
     end
 
     def retrieve_user_schedule(uuid:)

data/lib/calendlyr/resources/event_types.rb

@@ -1,8 +1,15 @@
 module Calendlyr
   class EventTypesResource < Resource
     def list(**params)
+      next_page_caller = ->(page_token:) { list(**params, page_token: page_token) }
+      params[:user] = expand_uri(params[:user], "users") if params[:user]
+      params[:organization] = expand_uri(params[:organization], "organizations") if params[:organization]
       response = get_request("event_types", params: params)
-      Collection.from_response(response, type: EventType, client: client)
+      Collection.from_response(response, type: EventType, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all(**params)
+      list(**params).auto_paginate.to_a
     end
 
     def retrieve(uuid:)
@@ -14,15 +21,48 @@ module Calendlyr
       EventType.new post_request("one_off_event_types", body: body).dig("resource").merge(client: client)
     end
 
-    def list_memberships(event_type:, **params)
-      response = get_request("event_type_memberships", params: {event_type: event_type}.merge(params))
-      Collection.from_response(response, type: EventTypes::Membership, client: client)
+    def create(name:, duration:, pooling_type:, **params)
+      body = {name: name, duration: duration, pooling_type: pooling_type}.merge(params)
+      EventType.new post_request("event_types", body: body).dig("resource").merge(client: client)
+    end
+
+    def update(uuid:, **params)
+      EventType.new patch_request("event_types/#{uuid}", body: params).dig("resource").merge(client: client)
+    end
+
+    # Availability Schedules
+    def list_availability_schedules(event_type_uuid:, **params)
+      next_page_caller = ->(page_token:) { list_availability_schedules(event_type_uuid: event_type_uuid, **params, page_token: page_token) }
+      response = get_request("event_type_availability_schedules", params: {event_type_uuid: event_type_uuid}.merge(params))
+      Collection.from_response(response, type: EventTypes::AvailabilitySchedule, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_availability_schedules(event_type_uuid:, **params)
+      list_availability_schedules(event_type_uuid: event_type_uuid, **params).auto_paginate.to_a
+    end
+
+    def update_availability_schedule(event_type_uuid:, availability_schedules:, **params)
+      body = {event_type_uuid: event_type_uuid, availability_schedules: availability_schedules}.merge(params)
+      patch_request("event_type_availability_schedules", body: body)
     end
 
-    # Available Times
+    # Available Times (no pagination — endpoint does not support it)
     def list_available_times(event_type:, start_time:, end_time:, **params)
+      event_type = expand_uri(event_type, "event_types")
       response = get_request("event_type_available_times", params: {event_type: event_type, start_time: start_time, end_time: end_time}.merge(params))
       Collection.from_response(response, type: EventTypes::AvailableTime, client: client)
     end
+
+    # Event Type Memberships
+    def list_memberships(event_type:, **params)
+      next_page_caller = ->(page_token:) { list_memberships(event_type: event_type, **params, page_token: page_token) }
+      event_type = expand_uri(event_type, "event_types")
+      response = get_request("event_type_memberships", params: {event_type: event_type}.merge(params))
+      Collection.from_response(response, type: EventTypes::Membership, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_memberships(event_type:, **params)
+      list_memberships(event_type: event_type, **params).auto_paginate.to_a
+    end
   end
 end

data/lib/calendlyr/resources/events.rb

@@ -1,8 +1,14 @@
 module Calendlyr
   class EventsResource < Resource
     def list(**params)
+      next_page_caller = ->(page_token:) { list(**params, page_token: page_token) }
+      params[:user] = expand_uri(params[:user], "users") if params[:user]
       response = get_request("scheduled_events", params: params)
-      Collection.from_response(response, type: Event, client: client)
+      Collection.from_response(response, type: Event, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all(**params)
+      list(**params).auto_paginate.to_a
     end
 
     def retrieve(uuid:)
@@ -15,20 +21,32 @@ module Calendlyr
 
     # Invitee
     def list_invitees(uuid:, **params)
+      next_page_caller = ->(page_token:) { list_invitees(uuid: uuid, **params, page_token: page_token) }
       response = get_request("scheduled_events/#{uuid}/invitees", params: params)
-      Collection.from_response(response, type: Events::Invitee, client: client)
+      Collection.from_response(response, type: Events::Invitee, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_invitees(uuid:, **params)
+      list_invitees(uuid: uuid, **params).auto_paginate.to_a
     end
 
     def retrieve_invitee(event_uuid:, invitee_uuid:)
       Events::Invitee.new get_request("scheduled_events/#{event_uuid}/invitees/#{invitee_uuid}").dig("resource").merge(client: client)
     end
 
+    def create_invitee(event_type:, start_time:, invitee:, **params)
+      event_type = expand_uri(event_type, "event_types")
+      body = {event_type: event_type, start_time: start_time, invitee: invitee}.merge(params)
+      Events::Invitee.new post_request("invitees", body: body).dig("invitee").merge(client: client)
+    end
+
     # Invitee No Show
     def retrieve_invitee_no_show(uuid:)
       Events::InviteeNoShow.new get_request("invitee_no_shows/#{uuid}").dig("resource").merge(client: client)
     end
 
     def create_invitee_no_show(invitee:)
+      invitee = expand_uri(invitee, "invitees")
       body = {invitee: invitee}
       Events::InviteeNoShow.new post_request("invitee_no_shows", body: body).dig("resource").merge(client: client)
     end