cloudflare-ruby 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e55c381f1697329fa6cb8bd393493b4b63b31d0f3b4b672d43e61c2799c0c40
-  data.tar.gz: dba84759f533e9203bb0f70404b4d719ece8509a883bb83d2aa5accd607d0375
+  metadata.gz: 230de80c474a3f8441f60687160aba0f2cd53c5db2d9465498866994150cc60f
+  data.tar.gz: 470768dc30305293361258880a74be07ea42832449ec4a77cae0079d42ca3cbc
 SHA512:
-  metadata.gz: e90e2f05d9b52b24195ff9d95c9849ff04290ac8d460ec0e59917869125e03cdc176a4717b2c1895891b463076d04ddbf30b17f4a8c52693d0f365bd6bef025f
-  data.tar.gz: 364098f7920cebdb13e6751be1bd28c32ba74b144e5a6f06e947a333a1b49b27efd5da9ae6befa3361253171df1755aa51816494f2b2821ee0190830733337e5
+  metadata.gz: 3416c0f5b271e376182525b183324d5ec7e0c11e5437f13194a75f35265c8463ac6d843414386e4fb1954966c340515f6eee2540e10b67bec1d6b50eae98574b
+  data.tar.gz: 7c2d7a9a594d06f674af34d26cf9a9570da463ac81e817aa56738d2a0332760c0116550c3adf68b1616cd019f33b2e9ccd24dbcf8ab7e414ef3e222d57e5e68d

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 0.3.0
+
+- **Per-product API tokens.** Set `Cloudflare::RealtimeKit.api_token` to
+  use a token scoped tightly to RealtimeKit (e.g., `Realtime: Edit` only).
+  Resolution chain when a request fires: per-call `api_token:` kwarg →
+  `Cloudflare::RealtimeKit.api_token` (per-product) → `Cloudflare.api_token`
+  (top-level fallback) → raise. Lets each product surface have its own
+  credentials so a leaked Realtime token can't touch R2/Workers/DNS.
+- `Connection#request` accepts a new `api_token:` kwarg; resolved token
+  flows through one place.
+- `Resource` gains a private `request(method, path, **opts)` helper
+  (class + instance) that wraps `Connection.instance.request` and injects
+  `configured_api_token` from the resource's product namespace. Subclasses
+  call `request(...)` instead of `Connection.instance.request(...)`.
+- Top-level `Cloudflare.api_token` still works as the fallback for
+  callers who don't want per-product separation. Backward-compatible.
+
+## 0.2.0
+
+- **Default `app_id` per process.** Set `Cloudflare::RealtimeKit.app_id`
+  once at boot and every RealtimeKit call defaults to it; pass `app_id:`
+  per-call only to override. Mirrors the existing `Cloudflare.account_id`
+  pattern. Eliminates `app_id:` repetition in apps that talk to a single
+  RealtimeKit app per process (the common case).
+- `Resource.build_scope` and `extract_scope!` now consult a generic
+  `global_default_for(key)` helper that resolves `:account_id` against
+  `Cloudflare.account_id` and any other key against a same-named
+  accessor on the resource's product namespace
+  (e.g., `:app_id` → `Cloudflare::RealtimeKit.app_id`). Generalizes for
+  future product surfaces.
+- `Recording.start_track`, `Recording.active_for`,
+  `Session.find_participant_by_peer_id`, `Analytics.daywise`, and
+  `Analytics.livestreams_overall` now accept `app_id:` as optional with
+  the default falling through.
+
 ## 0.1.2
 
 - Add `require "bundler/gem_tasks"` to the Rakefile so `rake release`

data/lib/cloudflare/connection.rb

@@ -8,11 +8,17 @@ module Cloudflare
       def reset!   = @instance = nil
     end
 
-    def request(method, path, body: nil, params: nil)
-      raise Error, "Cloudflare.api_token not configured" if Cloudflare.api_token.nil?
+    # Sends a Cloudflare API request. The +api_token+ kwarg is the resolved
+    # token chosen by the caller (typically +Resource.configured_api_token+ —
+    # per-product token if set, top-level +Cloudflare.api_token+ otherwise).
+    # It's a kwarg rather than a hardcoded read so admin tools can override
+    # per-call.
+    def request(method, path, body: nil, params: nil, api_token: nil)
+      token = api_token || Cloudflare.api_token
+      raise Error, "Cloudflare API token not configured" if token.nil?
 
       faraday.public_send(method, path.delete_prefix("/")) do |req|
-        req.headers["Authorization"] = "Bearer #{Cloudflare.api_token}"
+        req.headers["Authorization"] = "Bearer #{token}"
         req.headers["User-Agent"]    = Cloudflare.configuration.user_agent
         req.params = compact(params) if params
         req.body   = compact(body)   if body

data/lib/cloudflare/realtime_kit/README.md

@@ -8,14 +8,21 @@ Ruby bindings for [Cloudflare RealtimeKit](https://developers.cloudflare.com/rea
 require "cloudflare"
 
 Cloudflare.configure do |c|
-  c.api_token  = ENV.fetch("CLOUDFLARE_API_TOKEN")
   c.account_id = ENV.fetch("CLOUDFLARE_ACCOUNT_ID")
 end
 
+# Per-product API token + default app_id for every RealtimeKit call this
+# process makes. Pass `api_token:` / `app_id:` per-call only to override
+# (e.g., admin tools that hop between accounts or apps).
+Cloudflare::RealtimeKit.api_token = ENV.fetch("REALTIMEKIT_API_TOKEN")
+Cloudflare::RealtimeKit.app_id    = ENV.fetch("REALTIMEKIT_APP_ID")
+
 RK = Cloudflare::RealtimeKit  # alias to taste
 ```
 
-After that, `account_id:` is implicit on every call — pass it per-call only to override.
+After that, `account_id:`, `api_token:`, and `app_id:` are all implicit on every call — pass any per-call to override.
+
+If you'd rather use a single token across every Cloudflare product (less scope-tight but simpler), set `Cloudflare.api_token` instead and skip the per-product line — every product surface falls back to it.
 
 ## Apps
 
@@ -28,6 +35,8 @@ RK::App.all                          # GET  /apps
 
 ## Meetings
 
+Most calls below show `app_id:` for clarity. With `Cloudflare::RealtimeKit.app_id` set globally (see Setup), you can omit it.
+
 ```ruby
 meeting = RK::Meeting.create(app_id: app.id, title: "Standup", record_on_start: true)
 meeting.id            # => "mtg-…"

data/lib/cloudflare/realtime_kit/active_session.rb

@@ -36,31 +36,31 @@ module Cloudflare
 
       # POST .../active-session/kick — remove specified participants.
       def kick(participant_ids:, custom_participant_ids:)
-        Connection.instance.request(:post, "#{member_path}/kick",
+        request(:post, "#{member_path}/kick",
           body: { participant_ids: participant_ids, custom_participant_ids: custom_participant_ids })
       end
 
       # POST .../active-session/kick-all — remove every participant.
       def kick_all
-        Connection.instance.request(:post, "#{member_path}/kick-all")
+        request(:post, "#{member_path}/kick-all")
       end
 
       # POST .../active-session/mute — mute specified participants.
       def mute(participant_ids:, custom_participant_ids:)
-        Connection.instance.request(:post, "#{member_path}/mute",
+        request(:post, "#{member_path}/mute",
           body: { participant_ids: participant_ids, custom_participant_ids: custom_participant_ids })
       end
 
       # POST .../active-session/mute-all — mute every participant.
       # +allow_unmute+ controls whether participants can re-enable their mic.
       def mute_all(allow_unmute:)
-        Connection.instance.request(:post, "#{member_path}/mute-all",
+        request(:post, "#{member_path}/mute-all",
           body: { allow_unmute: allow_unmute })
       end
 
       # POST .../active-session/poll — broadcast a poll to participants.
       def create_poll(question:, options:, anonymous: nil, hide_votes: nil)
-        Connection.instance.request(:post, "#{member_path}/poll",
+        request(:post, "#{member_path}/poll",
           body: { question: question, options: options, anonymous: anonymous, hide_votes: hide_votes })
       end
     end

data/lib/cloudflare/realtime_kit/analytics.rb

@@ -18,14 +18,14 @@ module Cloudflare
     module Analytics
       class << self
         # GET /analytics/daywise — daily breakdown of meeting activity.
-        def daywise(app_id:, start_date:, end_date:, account_id: nil)
+        def daywise(start_date:, end_date:, app_id: nil, account_id: nil)
           fetch("/accounts/{account_id}/realtime/kit/{app_id}/analytics/daywise",
                 app_id: app_id, account_id: account_id,
                 params: { start_date: start_date, end_date: end_date })
         end
 
         # GET /analytics/livestreams/overall — overall livestream metrics.
-        def livestreams_overall(app_id:, start_time:, end_time:, account_id: nil)
+        def livestreams_overall(start_time:, end_time:, app_id: nil, account_id: nil)
           fetch("/accounts/{account_id}/realtime/kit/{app_id}/analytics/livestreams/overall",
                 app_id: app_id, account_id: account_id,
                 params: { start_time: start_time, end_time: end_time })
@@ -35,17 +35,23 @@ module Cloudflare
           def fetch(path_template, app_id:, account_id:, params:)
             scope    = build_scope(account_id: account_id, app_id: app_id)
             path     = interpolate(path_template, scope)
-            response = Connection.instance.request(:get, path, params: params)
+            response = Connection.instance.request(:get, path,
+              params: params, api_token: RealtimeKit.api_token || Cloudflare.api_token)
             Resource.unwrap_envelope(response)
           end
 
           # Local copies of the two private helpers from Resource — Analytics
           # isn't a Resource subclass (no instances, just a function namespace),
-          # so it can't inherit the private class methods.
+          # so it can't inherit the private class methods. Falls back to
+          # +Cloudflare.account_id+ and +Cloudflare::RealtimeKit.app_id+ for
+          # the same per-process default behavior the Resource subclasses
+          # get for free.
           def build_scope(account_id:, app_id:)
             account = account_id || Cloudflare.account_id
+            app     = app_id     || RealtimeKit.app_id
             raise ArgumentError, "missing required scope param: account_id" unless account
-            { account_id: account, app_id: app_id }
+            raise ArgumentError, "missing required scope param: app_id"     unless app
+            { account_id: account, app_id: app }
           end
 
           def interpolate(path, values)

data/lib/cloudflare/realtime_kit/app.rb

@@ -34,14 +34,14 @@ module Cloudflare
         # +{ data: [...] }+ envelope and don't need this dance.
         def create(name:, account_id: nil)
           scope    = build_scope(account_id: account_id)
-          response = Connection.instance.request(:post, interpolate(_collection_path, scope), body: { "name" => name })
+          response = request(:post, interpolate(_collection_path, scope), body: { "name" => name })
           new(unwrap_create_payload(response), scope: scope)
         end
 
         # GET /accounts/{account_id}/realtime/kit/apps
         def all(account_id: nil)
           scope    = build_scope(account_id: account_id)
-          response = Connection.instance.request(:get, interpolate(_collection_path, scope))
+          response = request(:get, interpolate(_collection_path, scope))
           Array(unwrap_envelope(response)).map { new(_1, scope: scope) }
         end
 

data/lib/cloudflare/realtime_kit/meeting.rb

@@ -43,14 +43,14 @@ module Cloudflare
       # PUT /meetings/{id} — full replacement. Mirrors +update+ but uses PUT
       # semantics, so omitted fields revert to their defaults upstream.
       def replace(**attrs)
-        response = Connection.instance.request(:put, member_path, body: self.class.to_wire_keys(attrs))
+        response = request(:put, member_path, body: self.class.to_wire_keys(attrs))
         set_attrs_from_response(response)
         self
       end
 
       # POST /meetings/{id}/livestreams — begin broadcasting this meeting.
       def start_livestreaming(name: nil, video_config: nil)
-        Connection.instance.request(:post, "#{member_path}/livestreams", body: { name: name, video_config: video_config })
+        request(:post, "#{member_path}/livestreams", body: { name: name, video_config: video_config })
       end
 
       # GET /meetings/{id}/active-livestream — fetch the currently-running
@@ -58,13 +58,13 @@ module Cloudflare
       # the same app, so you can chain regular livestream operations on it
       # (e.g., +meeting.active_livestream.active_session+).
       def active_livestream
-        response = Connection.instance.request(:get, "#{member_path}/active-livestream")
+        response = request(:get, "#{member_path}/active-livestream")
         Livestream.new(response, scope: { account_id: @scope[:account_id], app_id: @scope[:app_id] })
       end
 
       # POST /meetings/{id}/active-livestream/stop
       def stop_livestream
-        Connection.instance.request(:post, "#{member_path}/active-livestream/stop")
+        request(:post, "#{member_path}/active-livestream/stop")
       end
 
       # GET /meetings/{id}/livestream — legacy "livestream-session-details"
@@ -73,7 +73,7 @@ module Cloudflare
       # Returned as a raw Hash because the response bundles two distinct
       # shapes; the typed +Livestream+ + per-session lookup live elsewhere.
       def livestream_details(page_no: nil, per_page: nil)
-        response = Connection.instance.request(:get, "#{member_path}/livestream",
+        response = request(:get, "#{member_path}/livestream",
           params: { page_no: page_no, per_page: per_page })
         self.class.unwrap_envelope(response)
       end

data/lib/cloudflare/realtime_kit/participant.rb

@@ -31,7 +31,7 @@ module Cloudflare
       # Mints a fresh token for an existing participant (e.g., when their
       # previous token expired or was leaked).
       def regenerate_token
-        response = Connection.instance.request(:post, "#{member_path}/token")
+        response = request(:post, "#{member_path}/token")
         set_attrs_from_response(response)
         self
       end

data/lib/cloudflare/realtime_kit/recording.rb

@@ -38,21 +38,21 @@ module Cloudflare
         # POST /recordings/track — start a multi-file (per-track) recording.
         # Different upstream endpoint than +create+; use this when you need
         # one media file per participant track.
-        def start_track(meeting_id:, layers:, app_id:, account_id: nil, max_seconds: nil)
+        def start_track(meeting_id:, layers:, app_id: nil, account_id: nil, max_seconds: nil)
           scope    = build_scope(account_id: account_id, app_id: app_id)
           path     = interpolate("/accounts/{account_id}/realtime/kit/{app_id}/recordings/track", scope)
-          response = Connection.instance.request(:post, path,
+          response = request(:post, path,
             body: { meeting_id: meeting_id, layers: layers, max_seconds: max_seconds })
           new(response, scope: scope)
         end
 
         # GET /recordings/active-recording/{meeting_id} — fetch the recording
         # currently in progress for a meeting (404 if none).
-        def active_for(meeting_id:, app_id:, account_id: nil)
+        def active_for(meeting_id:, app_id: nil, account_id: nil)
           scope    = build_scope(account_id: account_id, app_id: app_id)
           path     = interpolate("/accounts/{account_id}/realtime/kit/{app_id}/recordings/active-recording/{meeting_id}",
                                  scope.merge(meeting_id: meeting_id))
-          response = Connection.instance.request(:get, path)
+          response = request(:get, path)
           new(response, scope: scope)
         end
       end
@@ -69,7 +69,7 @@ module Cloudflare
         unless TRANSITIONS.include?(sym)
           raise ArgumentError, "action must be one of #{TRANSITIONS.inspect}, got #{action.inspect}"
         end
-        response = Connection.instance.request(:put, member_path, body: { action: sym.to_s })
+        response = request(:put, member_path, body: { action: sym.to_s })
         set_attrs_from_response(response)
         self
       end

data/lib/cloudflare/realtime_kit/session.rb

@@ -41,11 +41,11 @@ module Cloudflare
         # GET /sessions/peer-report/{peer_id} — reverse lookup from a peer id.
         # Returns participant-shaped data, not a session, so we expose it as a
         # SessionParticipant instance.
-        def find_participant_by_peer_id(peer_id, app_id:, account_id: nil, filters: nil)
+        def find_participant_by_peer_id(peer_id, app_id: nil, account_id: nil, filters: nil)
           scope = build_scope(account_id: account_id, app_id: app_id)
           path  = interpolate("/accounts/{account_id}/realtime/kit/{app_id}/sessions/peer-report/{peer_id}",
                               scope.merge(peer_id: peer_id))
-          response = Connection.instance.request(:get, path, params: { filters: filters })
+          response = request(:get, path, params: { filters: filters })
           SessionParticipant.new(response, scope: scope)
         end
       end
@@ -58,7 +58,7 @@ module Cloudflare
       # so the two endpoints don't share scope and Relation can't model them
       # together cleanly.
       def livestream_sessions(page_no: nil, per_page: nil)
-        response = Connection.instance.request(:get, "#{member_path}/livestream-sessions",
+        response = request(:get, "#{member_path}/livestream-sessions",
           params: { page_no: page_no, per_page: per_page })
         Array(self.class.unwrap_envelope(response)).map do |item|
           LivestreamSession.new(item, scope: { account_id: @scope[:account_id], app_id: @scope[:app_id] })

data/lib/cloudflare/realtime_kit/summary.rb

@@ -19,7 +19,7 @@ module Cloudflare
 
       # POST /sessions/{session_id}/summary — generate a summary on demand.
       def generate
-        response = Connection.instance.request(:post, member_path)
+        response = request(:post, member_path)
         set_attrs_from_response(response)
         self
       end

data/lib/cloudflare/realtime_kit/webhook.rb

@@ -27,7 +27,7 @@ module Cloudflare
 
       # PUT /webhooks/{id} — replace every field (vs PATCH +update+).
       def replace(**attrs)
-        response = Connection.instance.request(:put, member_path, body: self.class.to_wire_keys(attrs))
+        response = request(:put, member_path, body: self.class.to_wire_keys(attrs))
         set_attrs_from_response(response)
         self
       end

data/lib/cloudflare/realtime_kit.rb

@@ -2,7 +2,36 @@ module Cloudflare
   # Cloudflare RealtimeKit (formerly Dyte) — managed video/audio infrastructure
   # for meetings, livestreams, recordings, sessions, and analytics. Each
   # resource maps to a hand-written class under this namespace.
+  #
+  # == Defaults
+  #
+  # Most resources (Meeting, Participant, Recording, ...) live under an app.
+  # Set +app_id+ once at process boot and every call defaults to it; pass
+  # +app_id:+ per-call only to override.
+  #
+  # +api_token+ is the per-product token. Resolution chain when a request
+  # fires: per-call +api_token:+ kwarg → +Cloudflare::RealtimeKit.api_token+
+  # → +Cloudflare.api_token+ (top-level fallback) → raise.
+  #
+  # Per-product tokens let you scope each product's credentials tightly
+  # (e.g., a token with +Realtime: Edit+ only) and rotate them
+  # independently. Top-level +Cloudflare.api_token+ stays as a fallback
+  # for callers who don't want per-product separation.
+  #
+  #   Cloudflare::RealtimeKit.api_token = ENV["REALTIMEKIT_API_TOKEN"]
+  #   Cloudflare::RealtimeKit.app_id    = ENV["REALTIMEKIT_APP_ID"]
+  #
+  #   Cloudflare::RealtimeKit::Meeting.create(title: "Standup")          # uses defaults
+  #   Cloudflare::RealtimeKit::Meeting.find(id, app_id: "other-app-id")  # override
   module RealtimeKit
+    class << self
+      # Default app_id used when a resource call doesn't pass one explicitly.
+      attr_accessor :app_id
+
+      # Per-product API token. Falls back to +Cloudflare.api_token+ when nil.
+      attr_accessor :api_token
+    end
+
     autoload :App,                     "cloudflare/realtime_kit/app"
     autoload :Meeting,                 "cloudflare/realtime_kit/meeting"
     autoload :Participant,             "cloudflare/realtime_kit/participant"

data/lib/cloudflare/resource.rb

@@ -160,31 +160,49 @@ module Cloudflare
       def create(**attrs)
         scope    = extract_scope!(attrs)
         path     = interpolate(_collection_path, scope)
-        response = Connection.instance.request(:post, path, body: to_wire_keys(attrs))
+        response = request(:post, path, body: to_wire_keys(attrs))
         new(response, scope: scope)
       end
 
       def find(id, **scope_attrs)
         scope    = build_scope(scope_attrs)
         path     = interpolate(_member_path, scope.merge(id: id))
-        response = Connection.instance.request(:get, path)
+        response = request(:get, path)
         new(response, scope: scope)
       end
 
       def all(**params)
         scope    = extract_scope!(params)
         path     = interpolate(_collection_path, scope)
-        response = Connection.instance.request(:get, path, params: to_wire_keys(params))
+        response = request(:get, path, params: to_wire_keys(params))
         items    = unwrap_envelope(response)
         Array(items).map { new(_1, scope: scope) }
       end
 
+      # Wraps +Connection.instance.request+ with the api_token resolved from
+      # the resource's product namespace. Subclasses (and instance methods,
+      # via the same-named instance helper) call this rather than
+      # +Connection.instance.request+ directly so the per-product token chain
+      # — per-call → product namespace token → top-level — is enforced
+      # uniformly.
+      def request(method, path, **opts)
+        Connection.instance.request(method, path, api_token: configured_api_token, **opts)
+      end
+
+      # Token resolution: per-product accessor (e.g., +Cloudflare::RealtimeKit.api_token+)
+      # if set, else +Cloudflare.api_token+. Connection raises when both are nil.
+      def configured_api_token
+        ns = product_namespace
+        (ns && ns.respond_to?(:api_token) && ns.api_token) || Cloudflare.api_token
+      end
+
       private
-        # Pulls scope params out of the kwargs hash (mutating). Defaults
-        # account_id from global config if not provided.
+        # Pulls scope params out of the kwargs hash (mutating). Falls back
+        # to product-level defaults (see +global_default_for+) when a key
+        # isn't provided.
         def extract_scope!(attrs)
           scope_params.each_with_object({}) do |key, h|
-            value = attrs.delete(key) || (key == :account_id && Cloudflare.account_id)
+            value = attrs.delete(key) || global_default_for(key)
             raise ArgumentError, "missing required scope param: #{key}" unless value
             h[key] = value
           end
@@ -192,12 +210,35 @@ module Cloudflare
 
         def build_scope(provided)
           scope_params.each_with_object({}) do |key, h|
-            value = provided[key] || (key == :account_id && Cloudflare.account_id)
+            value = provided[key] || global_default_for(key)
             raise ArgumentError, "missing required scope param: #{key}" unless value
             h[key] = value
           end
         end
 
+        # Resolve a scope key to its module-level default:
+        # +:account_id+ → +Cloudflare.account_id+ (top-level config), and any
+        # other key → a same-named accessor on the resource's product
+        # namespace (e.g., +:app_id+ → +Cloudflare::RealtimeKit.app_id+).
+        # Lets callers configure once per process and stop repeating
+        # +app_id:+ at every call site. Returns nil when no default is set,
+        # which lets the caller raise the +missing required scope+ error.
+        def global_default_for(key)
+          return Cloudflare.account_id if key == :account_id
+          namespace = product_namespace
+          namespace&.respond_to?(key) ? namespace.public_send(key) : nil
+        end
+
+        # +Cloudflare::RealtimeKit::Meeting+ → +Cloudflare::RealtimeKit+.
+        # Returns nil for resources without a product namespace (i.e.,
+        # +Cloudflare::Resource+ direct subclasses, which we don't have in
+        # practice).
+        def product_namespace
+          parts = name.split("::")
+          return nil if parts.size < 3
+          parts[0..-2].inject(Object) { |const, seg| const.const_get(seg) }
+        end
+
         def interpolate(path, values)
           path.gsub(/\{(\w+)\}/) do
             key = $1.to_sym
@@ -226,18 +267,18 @@ module Cloudflare
     def attributes  = (ensure_loaded!; @attrs)
 
     def update(**changes)
-      response = Connection.instance.request(:patch, member_path, body: self.class.to_wire_keys(changes))
+      response = request(:patch, member_path, body: self.class.to_wire_keys(changes))
       set_attrs_from_response(response)
       self
     end
 
     def destroy
-      Connection.instance.request(:delete, member_path)
+      request(:delete, member_path)
       freeze
     end
 
     def reload
-      response = Connection.instance.request(:get, member_path)
+      response = request(:get, member_path)
       set_attrs_from_response(response)
       self
     end
@@ -268,6 +309,14 @@ module Cloudflare
         reload unless @loaded
       end
 
+      # Instance-side wrapper around the class-level +request+. Lets custom
+      # action methods (e.g., +active_session.kick+) call +request(:post, ...)+
+      # without threading the api_token themselves; the class helper resolves
+      # it from the product namespace.
+      def request(method, path, **opts)
+        self.class.send(:request, method, path, **opts)
+      end
+
       def member_path
         self.class.send(:interpolate, self.class._member_path, @scope.merge(id: id))
       end

data/lib/cloudflare/version.rb

@@ -1,3 +1,3 @@
 module Cloudflare
-  VERSION = "0.1.2"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloudflare-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - tokimonki