calendlyr 0.7.5 → 1.0.0

data/lib/calendlyr/resources/groups.rb

@@ -1,8 +1,14 @@
 module Calendlyr
   class GroupsResource < Resource
     def list(organization:, **params)
+      next_page_caller = ->(page_token:) { list(organization: organization, **params, page_token: page_token) }
+      organization = expand_uri(organization, "organizations")
       response = get_request("groups", params: params.merge(organization: organization))
-      Collection.from_response(response, type: Group, client: client)
+      Collection.from_response(response, type: Group, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all(organization:, **params)
+      list(organization: organization, **params).auto_paginate.to_a
     end
 
     def retrieve(uuid:)
@@ -11,8 +17,14 @@ module Calendlyr
 
     # Relationships
     def list_relationships(**params)
+      next_page_caller = ->(page_token:) { list_relationships(**params, page_token: page_token) }
+      params[:organization] = expand_uri(params[:organization], "organizations") if params[:organization]
       response = get_request("group_relationships", params: params)
-      Collection.from_response(response, type: Groups::Relationship, client: client)
+      Collection.from_response(response, type: Groups::Relationship, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_relationships(**params)
+      list_relationships(**params).auto_paginate.to_a
     end
 
     def retrieve_relationship(uuid:)

data/lib/calendlyr/resources/locations.rb

@@ -0,0 +1,13 @@
+module Calendlyr
+  class LocationsResource < Resource
+    def list(**params)
+      next_page_caller = ->(page_token:) { list(**params, page_token: page_token) }
+      response = get_request("locations", params: params)
+      Collection.from_response(response, type: Location, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all(**params)
+      list(**params).auto_paginate.to_a
+    end
+  end
+end

data/lib/calendlyr/resources/organizations.rb

@@ -1,14 +1,31 @@
 module Calendlyr
   class OrganizationsResource < Resource
+    def retrieve(uuid:)
+      Organization.new get_request("organizations/#{uuid}").dig("resource").merge(client: client)
+    end
+
     def activity_log(organization: nil, **params)
+      next_page_caller = ->(page_token:) { activity_log(organization: organization, **params, page_token: page_token) }
+      organization = expand_uri(organization, "organizations")
       response = get_request("activity_log_entries", params: {organization: organization}.merge(params).compact)
-      Collection.from_response(response, type: ActivityLog, client: client)
+      Collection.from_response(response, type: ActivityLog, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_activity_log(organization: nil, **params)
+      activity_log(organization: organization, **params).auto_paginate.to_a
     end
 
     # Memberships
     def list_memberships(**params)
+      next_page_caller = ->(page_token:) { list_memberships(**params, page_token: page_token) }
+      params[:organization] = expand_uri(params[:organization], "organizations") if params[:organization]
+      params[:user] = expand_uri(params[:user], "users") if params[:user]
       response = get_request("organization_memberships", params: params)
-      Collection.from_response(response, type: Organizations::Membership, client: client)
+      Collection.from_response(response, type: Organizations::Membership, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_memberships(**params)
+      list_memberships(**params).auto_paginate.to_a
     end
 
     def retrieve_membership(uuid:)
@@ -21,8 +38,13 @@ module Calendlyr
 
     # Invitations
     def list_invitations(uuid:, **params)
+      next_page_caller = ->(page_token:) { list_invitations(uuid: uuid, **params, page_token: page_token) }
       response = get_request("organizations/#{uuid}/invitations", params: params)
-      Collection.from_response(response, type: Organizations::Invitation, client: client)
+      Collection.from_response(response, type: Organizations::Invitation, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_invitations(uuid:, **params)
+      list_invitations(uuid: uuid, **params).auto_paginate.to_a
     end
 
     def retrieve_invitation(org_uuid:, uuid:)

data/lib/calendlyr/resources/outgoing_communications.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 module Calendlyr
   class OutgoingCommunicationsResource < Resource
-    def list(**params)
-      response = get_request("outgoing_communications", params: params)
-      Collection.from_response(response, type: Object, client: client)
+    def list(organization:, **params)
+      next_page_caller = ->(page_token:) { list(organization: organization, **params, page_token: page_token) }
+      organization = expand_uri(organization, "organizations")
+      response = get_request("outgoing_communications", params: {organization: organization}.merge(params))
+      Collection.from_response(response, type: OutgoingCommunication, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all(organization:, **params)
+      list(organization: organization, **params).auto_paginate.to_a
     end
   end
 end

data/lib/calendlyr/resources/routing_forms.rb

@@ -1,8 +1,14 @@
 module Calendlyr
   class RoutingFormsResource < Resource
     def list(organization:, **params)
+      next_page_caller = ->(page_token:) { list(organization: organization, **params, page_token: page_token) }
+      organization = expand_uri(organization, "organizations")
       response = get_request("routing_forms", params: {organization: organization}.merge(params))
-      Collection.from_response(response, type: RoutingForm, client: client)
+      Collection.from_response(response, type: RoutingForm, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all(organization:, **params)
+      list(organization: organization, **params).auto_paginate.to_a
     end
 
     def retrieve(uuid:)
@@ -11,8 +17,14 @@ module Calendlyr
 
     # Routing Form Submission
     def list_submissions(form:, **params)
+      next_page_caller = ->(page_token:) { list_submissions(form: form, **params, page_token: page_token) }
+      form = expand_uri(form, "routing_forms")
       response = get_request("routing_form_submissions", params: {form: form}.merge(params))
-      Collection.from_response(response, type: RoutingForms::Submission, client: client)
+      Collection.from_response(response, type: RoutingForms::Submission, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all_submissions(form:, **params)
+      list_submissions(form: form, **params).auto_paginate.to_a
     end
 
     def retrieve_submission(uuid:)

data/lib/calendlyr/resources/scheduling_links.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module Calendlyr
   class SchedulingLinksResource < Resource
-    def create(owner:, max_event_count:, owner_type: "EventType")
-      body = {owner: owner, max_event_count: max_event_count, owner_type: owner_type}
+    def create(owner:, owner_type: "EventType", max_event_count: 1)
+      owner = expand_uri(owner, "event_types")
+      body = {max_event_count: max_event_count, owner: owner, owner_type: owner_type}
       SchedulingLink.new post_request("scheduling_links", body: body).dig("resource").merge(client: client)
     end
   end

data/lib/calendlyr/resources/shares.rb

@@ -1,6 +1,7 @@
 module Calendlyr
   class SharesResource < Resource
     def create(event_type:, **params)
+      event_type = expand_uri(event_type, "event_types")
       body = {event_type: event_type}.merge(params)
       Share.new post_request("shares", body: body).dig("resource").merge(client: client)
     end

data/lib/calendlyr/resources/webhooks.rb

@@ -1,11 +1,18 @@
 module Calendlyr
   class WebhooksResource < Resource
     def list(organization:, scope:, **params)
+      next_page_caller = ->(page_token:) { list(organization: organization, scope: scope, **params, page_token: page_token) }
+      organization = expand_uri(organization, "organizations")
       response = get_request("webhook_subscriptions", params: params.merge(organization: organization, scope: scope).compact)
-      Collection.from_response(response, type: Webhooks::Subscription, client: client)
+      Collection.from_response(response, type: Webhooks::Subscription, client: client, next_page_caller: next_page_caller)
+    end
+
+    def list_all(organization:, scope:, **params)
+      list(organization: organization, scope: scope, **params).auto_paginate.to_a
     end
 
     def create(url:, events:, organization:, scope:, **params)
+      organization = expand_uri(organization, "organizations")
       body = params.merge(url: url, events: events, organization: organization, scope: scope)
       Webhooks::Subscription.new post_request("webhook_subscriptions", body: body).dig("resource").merge(client: client)
     end
@@ -18,8 +25,9 @@ module Calendlyr
       delete_request("webhook_subscriptions/#{webhook_uuid}")
     end
 
-    def sample_webhook_data(event:, organization:, scope:, **params)
-      Object.new get_request("sample_webhook_data", params: params.merge(event: event, organization: organization, scope: scope)).merge(client: client)
+    def sample(event:, organization:, scope:, **params)
+      organization = expand_uri(organization, "organizations")
+      get_request("sample_webhook_data", params: {event: event, organization: organization, scope: scope}.merge(params))
     end
   end
 end

data/lib/calendlyr/version.rb

@@ -1,3 +1,3 @@
 module Calendlyr
-  VERSION = "0.7.5"
+  VERSION = "1.0.0"
 end

data/lib/calendlyr/webhook.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+
+module Calendlyr
+  module Webhook
+    DEFAULT_TOLERANCE = 300
+
+    module_function
+
+    def verify!(payload:, signing_key:, header: nil, signature_header: nil, tolerance: DEFAULT_TOLERANCE)
+      raise ArgumentError, "signing_key is required" if signing_key.nil? || signing_key.empty?
+
+      resolved_header = resolve_signature_header(header: header, signature_header: signature_header)
+      timestamp, provided_signature = parse_header(resolved_header)
+      verify_timestamp!(timestamp, tolerance)
+
+      expected_signature = compute_signature(payload, timestamp, signing_key)
+      return true if secure_compare?(expected_signature, provided_signature)
+
+      raise WebhookSignatureError, "Invalid webhook signature"
+    end
+
+    def valid?(payload:, signing_key:, header: nil, signature_header: nil, tolerance: DEFAULT_TOLERANCE)
+      verify!(payload: payload, header: header, signature_header: signature_header, signing_key: signing_key, tolerance: tolerance)
+    rescue WebhookSignatureError, WebhookTimestampError
+      false
+    end
+
+    def parse(payload:, signing_key:, header: nil, signature_header: nil, tolerance: DEFAULT_TOLERANCE)
+      verify!(payload: payload, header: header, signature_header: signature_header, signing_key: signing_key, tolerance: tolerance)
+      parsed_payload = JSON.parse(payload)
+      Webhooks::Payload.new(parsed_payload.merge(client: nil))
+    end
+
+    def resolve_signature_header(header:, signature_header:)
+      if header && signature_header && header != signature_header
+        raise ArgumentError, "Provide either header or signature_header"
+      end
+
+      header || signature_header
+    end
+    private_class_method :resolve_signature_header
+
+    def parse_header(header)
+      raise WebhookSignatureError, "Missing webhook signature header" if header.nil? || header.strip.empty?
+
+      pairs = header.split(",").map(&:strip)
+      parsed = Hash.new { |hash, key| hash[key] = [] }
+
+      pairs.each do |pair|
+        key, value = pair.split("=", 2)
+        raise WebhookSignatureError, "Malformed webhook signature header" if key.nil? || value.nil?
+
+        parsed[key] << value.strip
+      end
+
+      timestamp_value = extract_single!(parsed, "t")
+      signature_value = extract_single!(parsed, "v1")
+
+      raise WebhookSignatureError, "Malformed webhook timestamp" unless timestamp_value.match?(/\A\d+\z/)
+
+      normalized_signature = signature_value.downcase
+      raise WebhookSignatureError, "Malformed webhook signature" unless normalized_signature.match?(/\A\h{64}\z/)
+
+      [timestamp_value.to_i, normalized_signature]
+    end
+    private_class_method :parse_header
+
+    def extract_single!(parsed, key)
+      values = parsed[key]
+      raise WebhookSignatureError, "Missing #{key} in webhook signature header" if values.empty?
+      raise WebhookSignatureError, "Duplicate #{key} in webhook signature header" if values.size > 1
+
+      value = values.first
+      raise WebhookSignatureError, "Blank #{key} in webhook signature header" if value.nil? || value.empty?
+
+      value
+    end
+    private_class_method :extract_single!
+
+    def verify_timestamp!(timestamp, tolerance)
+      return if tolerance.nil?
+
+      age = Time.now.to_i - timestamp
+      return if age.abs <= tolerance
+
+      raise WebhookTimestampError, "Webhook timestamp outside tolerance"
+    end
+    private_class_method :verify_timestamp!
+
+    def compute_signature(payload, timestamp, signing_key)
+      OpenSSL::HMAC.hexdigest("SHA256", signing_key, "#{timestamp}.#{payload}")
+    end
+    private_class_method :compute_signature
+
+    def secure_compare?(expected_signature, provided_signature)
+      return false unless expected_signature.bytesize == provided_signature.bytesize
+
+      OpenSSL.fixed_length_secure_compare(expected_signature, provided_signature)
+    end
+    private_class_method :secure_compare?
+  end
+end

data/lib/calendlyr.rb

@@ -2,11 +2,54 @@ require "calendlyr/version"
 
 module Calendlyr
   autoload :Client, "calendlyr/client"
+  autoload :Configuration, "calendlyr/configuration"
   autoload :Collection, "calendlyr/collection"
   autoload :Object, "calendlyr/object"
   autoload :Resource, "calendlyr/resource"
 
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def client
+      raise ArgumentError, "Missing Calendly token. Configure it with Calendlyr.configure { |c| c.token = \"...\" }" if configuration.token.nil?
+
+      signature = configuration_signature
+      @client = nil if @client_signature != signature
+      @client ||= Client.new(**client_attributes)
+      @client_signature = signature
+      @client
+    end
+
+    def reset!
+      @configuration = nil
+      @client = nil
+      @client_signature = nil
+    end
+
+    private
+
+    def configuration_signature
+      [configuration.token, configuration.open_timeout, configuration.read_timeout, configuration.logger]
+    end
+
+    def client_attributes
+      {
+        token: configuration.token,
+        open_timeout: configuration.open_timeout,
+        read_timeout: configuration.read_timeout,
+        logger: configuration.logger
+      }
+    end
+  end
+
   # Errors
+  autoload :ERROR_TYPES, "calendlyr/error"
   autoload :BadRequest, "calendlyr/error"
   autoload :Error, "calendlyr/error"
   autoload :ExternalCalendarError, "calendlyr/error"
@@ -17,6 +60,9 @@ module Calendlyr
   autoload :Unauthenticated, "calendlyr/error"
   autoload :TooManyRequests, "calendlyr/error"
   autoload :ResponseErrorHandler, "calendlyr/error"
+  autoload :WebhookSignatureError, "calendlyr/error"
+  autoload :WebhookTimestampError, "calendlyr/error"
+  autoload :Webhook, "calendlyr/webhook"
 
   # High-level categories of Calendly API calls
   autoload :AvailabilityResource, "calendlyr/resources/availability"
@@ -25,6 +71,7 @@ module Calendlyr
   autoload :EventTypesResource, "calendlyr/resources/event_types"
   autoload :GroupsResource, "calendlyr/resources/groups"
   autoload :OrganizationsResource, "calendlyr/resources/organizations"
+  autoload :LocationsResource, "calendlyr/resources/locations"
   autoload :OutgoingCommunicationsResource, "calendlyr/resources/outgoing_communications"
   autoload :RoutingFormsResource, "calendlyr/resources/routing_forms"
   autoload :SchedulingLinksResource, "calendlyr/resources/scheduling_links"
@@ -38,6 +85,8 @@ module Calendlyr
   autoload :EventType, "calendlyr/objects/event_type"
   autoload :Group, "calendlyr/objects/group"
   autoload :Organization, "calendlyr/objects/organization"
+  autoload :Location, "calendlyr/objects/location"
+  autoload :OutgoingCommunication, "calendlyr/objects/outgoing_communication"
   autoload :RoutingForm, "calendlyr/objects/routing_form"
   autoload :SchedulingLink, "calendlyr/objects/scheduling_link"
   autoload :Share, "calendlyr/objects/share"
@@ -57,6 +106,7 @@ module Calendlyr
   end
 
   module EventTypes
+    autoload :AvailabilitySchedule, "calendlyr/objects/event_types/availability_schedule"
     autoload :AvailableTime, "calendlyr/objects/event_types/available_time"
     autoload :Membership, "calendlyr/objects/event_types/membership"
     autoload :Profile, "calendlyr/objects/event_types/profile"

data/test/calendlyr/client_test.rb

@@ -1,4 +1,6 @@
 require "test_helper"
+require "logger"
+require "stringio"
 
 class ClientTest < Minitest::Test
   def test_token
@@ -19,4 +21,31 @@ class ClientTest < Minitest::Test
     assert client.respond_to?(:users)
     refute client.respond_to?(:useers)
   end
+
+  def test_default_timeouts
+    new_client = Calendlyr::Client.new(token: "fake")
+
+    assert_equal 30, new_client.open_timeout
+    assert_equal 30, new_client.read_timeout
+  end
+
+  def test_custom_timeouts
+    new_client = Calendlyr::Client.new(token: "fake", open_timeout: 10, read_timeout: 15)
+
+    assert_equal 10, new_client.open_timeout
+    assert_equal 15, new_client.read_timeout
+  end
+
+  def test_default_logger_is_nil
+    new_client = Calendlyr::Client.new(token: "fake")
+
+    assert_nil new_client.logger
+  end
+
+  def test_custom_logger
+    logger = Logger.new(StringIO.new)
+    new_client = Calendlyr::Client.new(token: "fake", logger: logger)
+
+    assert_equal logger, new_client.logger
+  end
 end

data/test/calendlyr/collection_test.rb

@@ -0,0 +1,168 @@
+require "test_helper"
+
+class CollectionTest < Minitest::Test
+  def build_collection
+    data = [
+      Calendlyr::Object.new(name: "Alice"),
+      Calendlyr::Object.new(name: "Bob")
+    ]
+
+    Calendlyr::Collection.new(data: data, count: 2, next_page_url: nil, client: client)
+  end
+
+  def test_each_yields_items
+    collection = build_collection
+    names = []
+
+    collection.each do |item|
+      names << item.name
+    end
+
+    assert_equal %w[Alice Bob], names
+  end
+
+  def test_map_is_available_from_enumerable
+    collection = build_collection
+
+    assert_equal %w[Alice Bob], collection.map(&:name)
+  end
+
+  def test_collection_responds_to_select
+    collection = build_collection
+
+    assert collection.respond_to?(:select)
+  end
+
+  def test_count_without_block_returns_metadata_count
+    collection = Calendlyr::Collection.new(
+      data: [Calendlyr::Object.new(name: "Alice")],
+      count: 10,
+      next_page_url: nil,
+      client: client
+    )
+
+    assert_equal 10, collection.count
+  end
+
+  def test_count_with_block_uses_enumerable_count
+    collection = build_collection
+
+    assert_equal(1, collection.count { |item| item.name == "Alice" })
+  end
+
+  def test_count_with_argument_uses_enumerable_count
+    alice = Calendlyr::Object.new(name: "Alice")
+    collection = Calendlyr::Collection.new(
+      data: [alice, Calendlyr::Object.new(name: "Bob")],
+      count: 10,
+      next_page_url: nil,
+      client: client
+    )
+
+    assert_equal 1, collection.count(alice)
+  end
+
+  def test_next_page_returns_next_collection
+    next_data = [Calendlyr::Object.new(name: "Charlie")]
+    next_collection = Calendlyr::Collection.new(
+      data: next_data, count: 1, next_page_url: nil, client: client
+    )
+    caller_lambda = ->(page_token:) { next_collection }
+
+    collection = Calendlyr::Collection.new(
+      data: [Calendlyr::Object.new(name: "Alice")],
+      count: 1,
+      next_page_url: "https://api.calendly.com/scheduled_events?page_token=TOKEN123",
+      client: client,
+      next_page_caller: caller_lambda
+    )
+
+    result = collection.next_page
+
+    assert_equal next_collection, result
+    assert_equal Calendlyr::Collection, result.class
+  end
+
+  def test_next_page_returns_nil_when_no_token
+    collection = Calendlyr::Collection.new(
+      data: [Calendlyr::Object.new(name: "Alice")],
+      count: 1,
+      next_page_url: nil,
+      client: client,
+      next_page_caller: ->(page_token:) { raise "should not be called" }
+    )
+
+    assert_nil collection.next_page
+  end
+
+  def test_next_page_returns_nil_when_no_caller
+    collection = Calendlyr::Collection.new(
+      data: [Calendlyr::Object.new(name: "Alice")],
+      count: 1,
+      next_page_url: "https://api.calendly.com/scheduled_events?page_token=TOKEN123",
+      client: client
+    )
+
+    assert_nil collection.next_page
+  end
+
+  def test_auto_paginate_yields_all_items_across_pages
+    page3_data = [Calendlyr::Object.new(name: "Charlie")]
+    page3 = Calendlyr::Collection.new(
+      data: page3_data, count: 1, next_page_url: nil, client: client
+    )
+
+    page2_data = [Calendlyr::Object.new(name: "Bob")]
+    page2 = Calendlyr::Collection.new(
+      data: page2_data, count: 1,
+      next_page_url: "https://api.calendly.com/events?page_token=P3",
+      client: client,
+      next_page_caller: ->(page_token:) { page3 }
+    )
+
+    page1_data = [Calendlyr::Object.new(name: "Alice")]
+    page1 = Calendlyr::Collection.new(
+      data: page1_data, count: 1,
+      next_page_url: "https://api.calendly.com/events?page_token=P2",
+      client: client,
+      next_page_caller: ->(page_token:) { page2 }
+    )
+
+    result = page1.auto_paginate.to_a
+
+    assert_equal %w[Alice Bob Charlie], result.map(&:name)
+  end
+
+  def test_auto_paginate_empty_collection
+    collection = Calendlyr::Collection.new(
+      data: [], count: 0, next_page_url: nil, client: client
+    )
+
+    assert_equal [], collection.auto_paginate.to_a
+  end
+
+  def test_auto_paginate_lazy_does_not_prefetch
+    page2_called = false
+
+    page2_data = [Calendlyr::Object.new(name: "Bob")]
+    page2 = Calendlyr::Collection.new(
+      data: page2_data, count: 1, next_page_url: nil, client: client
+    )
+
+    page1_data = [Calendlyr::Object.new(name: "Alice")]
+    page1 = Calendlyr::Collection.new(
+      data: page1_data, count: 1,
+      next_page_url: "https://api.calendly.com/events?page_token=P2",
+      client: client,
+      next_page_caller: lambda { |page_token:|
+        page2_called = true
+        page2
+      }
+    )
+
+    result = page1.auto_paginate.first(1)
+
+    assert_equal ["Alice"], result.map(&:name)
+    refute page2_called, "Page 2 lambda should NOT have been called"
+  end
+end