twitchrb 1.10.0 → 2.0.0

data/lib/twitch/objects/guest_star_invite.rb

@@ -0,0 +1,4 @@
+module Twitch
+  class GuestStarInvite < Object
+  end
+end

data/lib/twitch/objects/guest_star_session.rb

@@ -0,0 +1,4 @@
+module Twitch
+  class GuestStarSession < Object
+  end
+end

data/lib/twitch/objects/guest_star_settings.rb

@@ -0,0 +1,4 @@
+module Twitch
+  class GuestStarSettings < Object
+  end
+end

data/lib/twitch/objects/shield_mode_status.rb

@@ -0,0 +1,4 @@
+module Twitch
+  class ShieldModeStatus < Object
+  end
+end

data/lib/twitch/objects/{tag.rb → team.rb}

@@ -1,4 +1,4 @@
 module Twitch
-  class Tag < Object
+  class Team < Object
   end
 end

data/lib/twitch/objects/user_active_extensions.rb

@@ -0,0 +1,4 @@
+module Twitch
+  class UserActiveExtensions < Object
+  end
+end

data/lib/twitch/objects/user_extension.rb

@@ -0,0 +1,4 @@
+module Twitch
+  class UserExtension < Object
+  end
+end

data/lib/twitch/resource.rb

@@ -10,27 +10,69 @@ module Twitch
 
     def get_request(url, params: {}, headers: {})
       validate_request_path!(url)
-      handle_response client.connection.get(url, params, headers)
+      execute_request { client.connection.get(url, params, headers) }
     end
 
     def post_request(url, body:, headers: {})
       validate_request_path!(url)
-      handle_response client.connection.post(url, body, headers)
+      execute_request { client.connection.post(url, body, headers) }
     end
 
     def patch_request(url, body:, headers: {})
       validate_request_path!(url)
-      handle_response client.connection.patch(url, body, headers)
+      execute_request { client.connection.patch(url, body, headers) }
     end
 
     def put_request(url, body:, headers: {})
       validate_request_path!(url)
-      handle_response client.connection.put(url, body, headers)
+      execute_request { client.connection.put(url, body, headers) }
     end
 
     def delete_request(url, params: {}, headers: {})
       validate_request_path!(url)
-      handle_response client.connection.delete(url, params, headers)
+      execute_request { client.connection.delete(url, params, headers) }
+    end
+
+    # Builds a Collection that can fetch its following pages by repeating the
+    # original GET request with the cursor as the after param
+    def collection(response, type:)
+      Collection.from_response(response, type: type, next_page: next_page_fetcher(response, type))
+    end
+
+    def next_page_fetcher(response, type)
+      return unless response.respond_to?(:env) && response.env.method == :get
+
+      url = response.env.url
+      path = url.path.delete_prefix("#{URI(Client::BASE_URL).path}/")
+      params = Faraday::FlatParamsEncoder.decode(url.query) || {}
+      params.delete("before")
+
+      ->(cursor) { collection(get_request(path, params: params.merge("after" => cursor)), type: type) }
+    end
+
+    # Builds a path with a query string, for write endpoints that take some parameters
+    # in the query string rather than the body. nil values are dropped.
+    def query_path(path, params)
+      "#{path}?#{URI.encode_www_form(params.compact)}"
+    end
+
+    def execute_request
+      access_token = client.access_token
+      response = yield
+
+      # Retry once with a refreshed token if the access token has expired
+      if response.status == 401 && client.refresh_after_unauthorized(response, access_token)
+        response = yield
+      end
+
+      # Retry once after a 429, waiting until the rate limit window resets
+      if response.status == 429 && client.auto_retry_rate_limit
+        update_rate_limit(response)
+        client.rate_limiter.wait_if_rate_limited
+        response = yield
+      end
+
+      handle_response(response)
     end
 
     def handle_response(response)
@@ -44,8 +86,8 @@ module Twitch
     end
 
     def error?(response)
-      [ 400, 401, 403, 404, 409, 429, 500, 501, 503 ].include?(response.status) ||
-        response.body&.key?("error")
+      response.status >= 400 ||
+        (response.body.is_a?(Hash) && response.body.key?("error"))
     end
 
     def raise_error(response)
@@ -58,8 +100,6 @@ module Twitch
       raise error if error
     end
 
-    private
-
     def update_rate_limit(response)
       client.rate_limiter.update(response.headers)
       client.rate_limiter.warn_if_approaching(threshold: client.rate_limit_threshold)

data/lib/twitch/resources/ads.rb

@@ -0,0 +1,18 @@
+module Twitch
+  class AdsResource < Resource
+    # Required scope: channel:read:ads
+    # broadcaster_id must match the user in the OAuth token
+    def schedule(broadcaster_id:)
+      response = get_request("channels/ads", params: { broadcaster_id: broadcaster_id })
+      AdSchedule.new(response.body.dig("data")[0])
+    end
+
+    # Pushes back the next scheduled ad by 5 minutes
+    # Required scope: channel:manage:ads
+    # broadcaster_id must match the user in the OAuth token
+    def snooze(broadcaster_id:)
+      response = post_request(query_path("channels/ads/schedule/snooze", broadcaster_id: broadcaster_id), body: {})
+      AdSchedule.new(response.body.dig("data")[0])
+    end
+  end
+end

data/lib/twitch/resources/analytics.rb

@@ -0,0 +1,19 @@
+module Twitch
+  class AnalyticsResource < Resource
+    # Gets URLs for downloadable CSV reports about the user's extensions
+    # Required scope: analytics:read:extensions
+    # Available parameters: extension_id, type, started_at, ended_at, first, after
+    def extensions(**params)
+      response = get_request("analytics/extensions", params: params)
+      collection(response, type: AnalyticsReport)
+    end
+
+    # Gets URLs for downloadable CSV reports about the user's games
+    # Required scope: analytics:read:games
+    # Available parameters: game_id, type, started_at, ended_at, first, after
+    def games(**params)
+      response = get_request("analytics/games", params: params)
+      collection(response, type: AnalyticsReport)
+    end
+  end
+end

data/lib/twitch/resources/announcements.rb

@@ -5,7 +5,7 @@ module Twitch
     def create(broadcaster_id:, moderator_id:, message:, color: nil, for_source_only: nil)
       attrs = { message: message, color: color, for_source_only: for_source_only }
 
-      post_request("chat/announcements?broadcaster_id=#{broadcaster_id}&moderator_id=#{moderator_id}", body: attrs)
+      post_request(query_path("chat/announcements", broadcaster_id: broadcaster_id, moderator_id: moderator_id), body: attrs)
     end
   end
 end

data/lib/twitch/resources/automod.rb

@@ -3,17 +3,17 @@ module Twitch
     # Checks if a supplied message meets the channel's AutoMod requirements
     # Required scope: moderation:read
     def check_status(broadcaster_id:, id:, text:)
-      attrs = { broadcaster_id: broadcaster_id, data: [ { msg_id: id, msg_text: text } ] }
-      response = post_request("moderation/enforcements/status", body: attrs)
+      attrs = { data: [ { msg_id: id, msg_text: text } ] }
+      response = post_request(query_path("moderation/enforcements/status", broadcaster_id: broadcaster_id), body: attrs)
       AutomodStatus.new response.body.dig("data")[0]
     end
 
     # Checks if multiple supplied messages meet the channel's AutoMod requirements
     # Required scope: moderation:read
     def check_status_multiple(broadcaster_id:, messages:)
-      attrs = { broadcaster_id: broadcaster_id, data: messages }
-      response = post_request("moderation/enforcements/status", body: attrs)
-      Collection.from_response(response, type: AutomodStatus)
+      attrs = { data: messages }
+      response = post_request(query_path("moderation/enforcements/status", broadcaster_id: broadcaster_id), body: attrs)
+      collection(response, type: AutomodStatus)
     end
 
     def manage_message(user_id:, msg_id:, action:)
@@ -22,13 +22,13 @@ module Twitch
     end
 
     def settings(broadcaster_id:, moderator_id:)
-      response = get_request("moderation/automod/settings?broadcaster_id=#{broadcaster_id}&moderator_id=#{moderator_id}")
+      response = get_request("moderation/automod/settings", params: { broadcaster_id: broadcaster_id, moderator_id: moderator_id })
       AutomodSetting.new response.body.dig("data")[0]
     end
 
     def update_settings(broadcaster_id:, moderator_id:, **params)
-      attrs = { broadcaster_id: broadcaster_id, moderator_id: moderator_id }
-      response = put_request("moderation/automod/settings", body: attrs.merge(params))
+      path = query_path("moderation/automod/settings", broadcaster_id: broadcaster_id, moderator_id: moderator_id)
+      response = put_request(path, body: params)
       AutomodSetting.new response.body.dig("data")[0]
     end
   end

data/lib/twitch/resources/badges.rb

@@ -1,13 +1,13 @@
 module Twitch
   class BadgesResource < Resource
     def channel(broadcaster_id:)
-      response = get_request("chat/badges?broadcaster_id=#{broadcaster_id}")
-      Collection.from_response(response, type: Badge)
+      response = get_request("chat/badges", params: { broadcaster_id: broadcaster_id })
+      collection(response, type: Badge)
     end
 
     def global
       response = get_request("chat/badges/global")
-      Collection.from_response(response, type: Badge)
+      collection(response, type: Badge)
     end
   end
 end

data/lib/twitch/resources/banned_users.rb

@@ -3,21 +3,21 @@ module Twitch
     # Broadcaster ID must match the user in the OAuth token
     def list(broadcaster_id:, **params)
       response = get_request("moderation/banned", params: params.merge(broadcaster_id: broadcaster_id))
-      Collection.from_response(response, type: BannedUser)
+      collection(response, type: BannedUser)
     end
 
     # Required scope: moderator:manage:banned_users
     # moderator_id must match the currently authenticated user. Can be either the broadcaster ID or moderator ID
     def create(broadcaster_id:, moderator_id:, user_id:, reason:, duration: nil)
-      attrs = { broadcaster_id: broadcaster_id, moderator_id: moderator_id, data: { user_id: user_id, reason: reason, duration: duration } }
-      response = post_request("moderation/bans", body: attrs)
+      path = query_path("moderation/bans", broadcaster_id: broadcaster_id, moderator_id: moderator_id)
+      response = post_request(path, body: { data: { user_id: user_id, reason: reason, duration: duration }.compact })
       BannedUser.new response.body.dig("data")[0]
     end
 
     # Required scope: moderator:manage:banned_users
     # moderator_id must match the currently authenticated user. Can be either the broadcaster ID or moderator ID
     def delete(broadcaster_id:, moderator_id:, user_id:)
-      delete_request("moderation/bans?broadcaster_id=#{broadcaster_id}&moderator_id=#{moderator_id}&user_id=#{user_id}")
+      delete_request("moderation/bans", params: { broadcaster_id: broadcaster_id, moderator_id: moderator_id, user_id: user_id })
     end
   end
 end

data/lib/twitch/resources/bits.rb

@@ -0,0 +1,16 @@
+module Twitch
+  class BitsResource < Resource
+    # Required scope: bits:read
+    # Available parameters: count, period, started_at, user_id
+    def leaderboard(**params)
+      response = get_request("bits/leaderboard", params: params)
+      collection(response, type: BitsLeaderboardEntry)
+    end
+
+    # Pass broadcaster_id to include the broadcaster's custom Cheermotes
+    def cheermotes(broadcaster_id: nil)
+      response = get_request("bits/cheermotes", params: { broadcaster_id: broadcaster_id }.compact)
+      collection(response, type: Cheermote)
+    end
+  end
+end

data/lib/twitch/resources/blocked_terms.rb

@@ -5,21 +5,21 @@ module Twitch
     def list(broadcaster_id:, moderator_id:, **params)
       attrs = { broadcaster_id: broadcaster_id, moderator_id: moderator_id }
       response = get_request("moderation/blocked_terms", params: attrs.merge(params))
-      Collection.from_response(response, type: BlockedTerm)
+      collection(response, type: BlockedTerm)
     end
 
     # Required scope: moderator:manage:blocked_terms
     # moderator_id must match the currently authenticated user. Can be either the broadcaster ID or moderator ID
     def create(broadcaster_id:, moderator_id:, text:)
-      attrs = { broadcaster_id: broadcaster_id, moderator_id: moderator_id, text: text }
-      response = post_request("moderation/blocked_terms", body: attrs)
-      BannedUser.new response.body.dig("data")[0]
+      path = query_path("moderation/blocked_terms", broadcaster_id: broadcaster_id, moderator_id: moderator_id)
+      response = post_request(path, body: { text: text })
+      BlockedTerm.new response.body.dig("data")[0]
     end
 
     # Required scope: moderator:manage:blocked_terms
     # moderator_id must match the currently authenticated user. Can be either the broadcaster ID or moderator ID
     def delete(broadcaster_id:, moderator_id:, id:)
-      delete_request("moderation/blocked_terms?broadcaster_id=#{broadcaster_id}&moderator_id=#{moderator_id}&id=#{id}")
+      delete_request("moderation/blocked_terms", params: { broadcaster_id: broadcaster_id, moderator_id: moderator_id, id: id })
     end
   end
 end

data/lib/twitch/resources/channels.rb

@@ -1,7 +1,7 @@
 module Twitch
   class ChannelsResource < Resource
     def retrieve(id:)
-      Channel.new get_request("channels?broadcaster_id=#{id}").body.dig("data")[0]
+      Channel.new get_request("channels", params: { broadcaster_id: id }).body.dig("data")[0]
     end
 
     # Retrieve a list of broadcasters a specified user follows
@@ -9,7 +9,7 @@ module Twitch
     # user_id must match the authenticated user
     def followed(user_id:, **params)
       response = get_request("channels/followed", params: params.merge(user_id: user_id))
-      Collection.from_response(response, type: User)
+      collection(response, type: User)
     end
 
     # Retrieve a list of users that follow a specified broadcaster
@@ -17,7 +17,7 @@ module Twitch
     # broadcaster_id must match the authenticated user
     def followers(broadcaster_id:, **params)
       response = get_request("channels/followers", params: params.merge(broadcaster_id: broadcaster_id))
-      Collection.from_response(response, type: User)
+      collection(response, type: User)
     end
 
     # Grabs the number of Followers a broadcaster has
@@ -37,17 +37,17 @@ module Twitch
 
     # Requires scope: channel:manage:broadcast
     def update(broadcaster_id:, **attributes)
-      patch_request("channels", body: attributes.merge(broadcaster_id: broadcaster_id))
+      patch_request(query_path("channels", broadcaster_id: broadcaster_id), body: attributes)
     end
 
     # Requires scope: channel:read:editors
     def editors(broadcaster_id:)
-      response = get_request("channels/editors?broadcaster_id=#{broadcaster_id}")
-      Collection.from_response(response, type: ChannelEditor)
+      response = get_request("channels/editors", params: { broadcaster_id: broadcaster_id })
+      collection(response, type: ChannelEditor)
     end
 
     def stream_key(broadcaster_id:)
-      response = get_request("streams/key?broadcaster_id=#{broadcaster_id}")
+      response = get_request("streams/key", params: { broadcaster_id: broadcaster_id })
       StreamKey.new(response.body.dig("data")[0])
     end
 

data/lib/twitch/resources/charity_campaigns.rb

@@ -3,12 +3,20 @@ module Twitch
     # Required scope: channel:read:charity
     # Broadcaster ID must match the user in the OAuth token
     def list(broadcaster_id:)
-      response = get_request("charity/campaigns?broadcaster_id=#{broadcaster_id}")
+      response = get_request("charity/campaigns", params: { broadcaster_id: broadcaster_id })
       if response.body.dig("data")[0]
         CharityCampaign.new(response.body.dig("data")[0])
       else
         nil
       end
     end
+
+    # Required scope: channel:read:charity
+    # Broadcaster ID must match the user in the OAuth token
+    # Available parameters: first, after
+    def donations(broadcaster_id:, **params)
+      response = get_request("charity/donations", params: params.merge(broadcaster_id: broadcaster_id))
+      collection(response, type: CharityDonation)
+    end
   end
 end

data/lib/twitch/resources/chat_messages.rb

@@ -16,7 +16,7 @@ module Twitch
 
     # moderator_id must match the user in the OAuth token
     def delete(broadcaster_id:, moderator_id:, message_id:)
-      delete_request("moderation/chat?broadcaster_id=#{broadcaster_id}&moderator_id=#{moderator_id}&message_id=#{message_id}")
+      delete_request("moderation/chat", params: { broadcaster_id: broadcaster_id, moderator_id: moderator_id, message_id: message_id })
     end
   end
 end

data/lib/twitch/resources/chat_settings.rb

@@ -0,0 +1,20 @@
+module Twitch
+  class ChatSettingsResource < Resource
+    # moderator_id is only needed to include non_moderator_chat_delay settings,
+    # and must match the user in the OAuth token
+    def retrieve(broadcaster_id:, moderator_id: nil)
+      response = get_request("chat/settings", params: { broadcaster_id: broadcaster_id, moderator_id: moderator_id }.compact)
+      ChatSettings.new(response.body.dig("data")[0])
+    end
+
+    # Required scope: moderator:manage:chat_settings
+    # moderator_id must match the user in the OAuth token
+    # Available attributes: emote_mode, follower_mode, follower_mode_duration, non_moderator_chat_delay,
+    # non_moderator_chat_delay_duration, slow_mode, slow_mode_wait_time, subscriber_mode, unique_chat_mode
+    def update(broadcaster_id:, moderator_id:, **attributes)
+      path = query_path("chat/settings", broadcaster_id: broadcaster_id, moderator_id: moderator_id)
+      response = patch_request(path, body: attributes)
+      ChatSettings.new(response.body.dig("data")[0])
+    end
+  end
+end

data/lib/twitch/resources/chatters.rb

@@ -7,7 +7,7 @@ module Twitch
       attrs = { broadcaster_id: broadcaster_id, moderator_id: moderator_id }
       response = get_request("chat/chatters", params: attrs.merge(params))
 
-      Collection.from_response(response, type: Chatter)
+      collection(response, type: Chatter)
     end
   end
 end

data/lib/twitch/resources/clips.rb

@@ -1,10 +1,10 @@
 module Twitch
   class ClipsResource < Resource
     def list(**params)
-      raise "broadcaster_id or game_id is required" unless !params[:broadcaster_id].nil? || !params[:game_id].nil?
+      raise ArgumentError, "broadcaster_id, game_id or id is required" if params.values_at(:broadcaster_id, :game_id, :id).all?(&:nil?)
 
       response = get_request("clips", params: params)
-      Collection.from_response(response, type: Clip)
+      collection(response, type: Clip)
     end
 
     def retrieve(id:)
@@ -37,13 +37,7 @@ module Twitch
       ids = clip_ids || Array(clip_id)
       response = get_request("clips/downloads", params: { editor_id: editor_id, broadcaster_id: broadcaster_id, clip_id: ids })
 
-      Collection.from_response(response, type: ClipDownload)
-    end
-
-    private
-
-    def query_path(path, params)
-      "#{path}?#{URI.encode_www_form(params)}"
+      collection(response, type: ClipDownload)
     end
   end
 end

data/lib/twitch/resources/content_classification_labels.rb

@@ -0,0 +1,8 @@
+module Twitch
+  class ContentClassificationLabelsResource < Resource
+    def list(locale: nil)
+      response = get_request("content_classification_labels", params: { locale: locale }.compact)
+      collection(response, type: ContentClassificationLabel)
+    end
+  end
+end

data/lib/twitch/resources/custom_power_ups.rb

@@ -7,7 +7,7 @@ module Twitch
       params[:id] = ids if ids
 
       response = get_request("bits/custom_power_ups", params: params)
-      Collection.from_response(response, type: CustomPowerUp)
+      collection(response, type: CustomPowerUp)
     end
   end
 end

data/lib/twitch/resources/custom_reward_redemptions.rb

@@ -5,15 +5,14 @@ module Twitch
     def list(broadcaster_id:, reward_id:, status:, **params)
       attributes = { broadcaster_id: broadcaster_id, reward_id: reward_id, status: status.upcase }
       response = get_request("channel_points/custom_rewards/redemptions", params: attributes.merge(params))
-      Collection.from_response(response, type: CustomRewardRedemption)
+      collection(response, type: CustomRewardRedemption)
     end
 
     # Required scope: channel:manage:redemptions
     # Broadcaster ID must match the user in the OAuth token
     def update(broadcaster_id:, reward_id:, redemption_id:, status:)
-      attributes = { status: status.upcase }
-      url = "channel_points/custom_rewards/redemptions?broadcaster_id=#{broadcaster_id}&reward_id=#{reward_id}&id=#{redemption_id}&status=#{status.upcase}"
-      response = patch_request(url, body: attributes)
+      path = query_path("channel_points/custom_rewards/redemptions", broadcaster_id: broadcaster_id, reward_id: reward_id, id: redemption_id)
+      response = patch_request(path, body: { status: status.upcase })
 
       CustomRewardRedemption.new(response.body.dig("data")[0]) if response.success?
     end

data/lib/twitch/resources/custom_rewards.rb

@@ -4,19 +4,19 @@ module Twitch
     # Broadcaster ID must match the user in the OAuth token
     def list(broadcaster_id:, **params)
       response = get_request("channel_points/custom_rewards", params: params.merge(broadcaster_id: broadcaster_id))
-      Collection.from_response(response, type: CustomReward)
+      collection(response, type: CustomReward)
     end
 
     def create(broadcaster_id:, title:, cost:, **params)
-      attributes = { broadcaster_id: broadcaster_id, title: title, cost: cost }
-      response = post_request("channel_points/custom_rewards", body: attributes.merge(params))
+      attributes = { title: title, cost: cost }
+      response = post_request(query_path("channel_points/custom_rewards", broadcaster_id: broadcaster_id), body: attributes.merge(params))
 
       CustomReward.new(response.body.dig("data")[0]) if response.success?
     end
 
     def update(broadcaster_id:, reward_id:, **params)
-      attributes = { broadcaster_id: broadcaster_id, id: reward_id }
-      response = patch_request("channel_points/custom_rewards", body: attributes.merge(params))
+      path = query_path("channel_points/custom_rewards", broadcaster_id: broadcaster_id, id: reward_id)
+      response = patch_request(path, body: params)
 
       CustomReward.new(response.body.dig("data")[0]) if response.success?
     end

data/lib/twitch/resources/drops_entitlements.rb

@@ -0,0 +1,17 @@
+module Twitch
+  class DropsEntitlementsResource < Resource
+    # The Client ID must be owned by a member of the organization that owns the game
+    # Available parameters: id, user_id, game_id, fulfillment_status, first, after
+    def list(**params)
+      response = get_request("entitlements/drops", params: params)
+      collection(response, type: DropsEntitlement)
+    end
+
+    # fulfillment_status: CLAIMED or FULFILLED
+    # Returns a collection of results grouped by status, each with the affected ids
+    def update(entitlement_ids:, fulfillment_status:)
+      response = patch_request("entitlements/drops", body: { entitlement_ids: Array(entitlement_ids), fulfillment_status: fulfillment_status })
+      collection(response, type: DropsEntitlementUpdate)
+    end
+  end
+end

data/lib/twitch/resources/emotes.rb

@@ -1,18 +1,18 @@
 module Twitch
   class EmotesResource < Resource
     def channel(broadcaster_id:)
-      response = get_request("chat/emotes?broadcaster_id=#{broadcaster_id}")
-      Collection.from_response(response, type: Emote)
+      response = get_request("chat/emotes", params: { broadcaster_id: broadcaster_id })
+      collection(response, type: Emote)
     end
 
     def global
       response = get_request("chat/emotes/global")
-      Collection.from_response(response, type: Emote)
+      collection(response, type: Emote)
     end
 
     def sets(emote_set_id:)
-      response = get_request("chat/emotes/set?emote_set_id=#{emote_set_id}")
-      Collection.from_response(response, type: Emote)
+      response = get_request("chat/emotes/set", params: { emote_set_id: emote_set_id })
+      collection(response, type: Emote)
     end
   end
 end

data/lib/twitch/resources/eventsub_conduits.rb

@@ -1,8 +1,10 @@
 module Twitch
   class EventsubConduitsResource < Resource
+    MAX_SHARDS_PER_UPDATE = 100
+
     def list(**params)
       response = get_request("eventsub/conduits", params: params)
-      Collection.from_response(response, type: EventsubConduit)
+      collection(response, type: EventsubConduit)
     end
 
     def create(shard_count:)
@@ -23,12 +25,20 @@ module Twitch
 
     def shards(id:, **params)
       response = get_request("eventsub/conduits/shards", params: { conduit_id: id }.merge(params))
-      Collection.from_response(response, type: EventsubConduitShard)
+      collection(response, type: EventsubConduitShard)
     end
 
+    # Twitch accepts up to 100 shards per request, so larger lists are sent in batches.
+    # Returns the updated shards. Shards that failed to update are listed in #errors
+    # (each with id, message and code), as Twitch applies the rest of the update anyway.
     def update_shards(id:, shards:)
-      response = patch_request("eventsub/conduits/shards", body: { conduit_id: id, shards: shards })
-      Collection.from_response(response, type: EventsubConduitShard)
+      results = shards.each_slice(MAX_SHARDS_PER_UPDATE).map do |batch|
+        response = patch_request("eventsub/conduits/shards", body: { conduit_id: id, shards: batch })
+        collection(response, type: EventsubConduitShard)
+      end
+
+      data = results.flat_map(&:data)
+      Collection.new(data: data, total: data.size, cursor: nil, errors: results.flat_map(&:errors))
     end
   end
 end

data/lib/twitch/resources/eventsub_subscriptions.rb

@@ -2,25 +2,21 @@ module Twitch
   class EventsubSubscriptionsResource < Resource
     def list(**params)
       response = get_request("eventsub/subscriptions", params: params)
-      Collection.from_response(response, type: EventsubSubscription)
+      collection(response, type: EventsubSubscription)
     end
 
     def create(type:, version:, condition:, transport:, **params)
       attributes = { type: type, version: version, condition: condition, transport: transport }.merge(params)
-      response = client.connection.post("eventsub/subscriptions", attributes)
-      update_rate_limit(response)
-
-      if response.status == 409
-        raise Twitch::Errors::EventsubSubscriptionConflictError.new(
-          response.body,
-          response.status,
-          existing_subscription_id: response.body.dig("data", 0, "id")
-        )
-      end
-
-      return raise_error(response) if error?(response)
+      response = post_request("eventsub/subscriptions", body: attributes)
 
       EventsubSubscription.new(response.body.dig("data")[0]) if response.success?
+    rescue Twitch::Errors::ConflictError => error
+      existing_id = error.response_body.dig("data", 0, "id") if error.response_body.is_a?(Hash)
+      raise Twitch::Errors::EventsubSubscriptionConflictError.new(
+        error.response_body,
+        error.http_status_code,
+        existing_subscription_id: existing_id
+      )
     end
 
     def delete(id:)