screenshotfreeapi 1.0.0

data/lib/screenshotfreeapi/http_client.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module ScreenshotFreeAPI
+  # Low-level HTTP client responsible for:
+  #   - Building requests with correct headers
+  #   - Parsing JSON responses
+  #   - Mapping HTTP error statuses to typed exceptions
+  #   - Retrying transient failures (429, 5xx) with exponential backoff
+  class HttpClient
+    DEFAULT_BASE_URL  = "https://api.screenshotfreeapi.com"
+    DEFAULT_TIMEOUT   = 30
+    DEFAULT_RETRIES   = 3
+    DEFAULT_DELAY     = 1 # seconds — doubles on each retry: 1s, 2s, 4s
+
+    # @param api_key      [String]  Bearer token (API key or JWT)
+    # @param base_url     [String]  Override for testing / staging
+    # @param timeout      [Integer] Open/read timeout in seconds
+    # @param max_retries  [Integer] Maximum number of retry attempts (not counting the first try)
+    # @param retry_delay  [Numeric] Base delay in seconds; doubles each retry
+    def initialize(
+      api_key:,
+      base_url:    DEFAULT_BASE_URL,
+      timeout:     DEFAULT_TIMEOUT,
+      max_retries: DEFAULT_RETRIES,
+      retry_delay: DEFAULT_DELAY
+    )
+      raise ArgumentError, "api_key is required" if api_key.nil? || api_key.to_s.strip.empty?
+
+      @api_key     = api_key
+      @base_url    = base_url.to_s.chomp("/")
+      @timeout     = timeout
+      @max_retries = max_retries
+      @retry_delay = retry_delay
+    end
+
+    # Perform an HTTP request with automatic retry on transient errors.
+    #
+    # @param method      [Symbol]  :get, :post, :patch, :delete
+    # @param path        [String]  Path starting with "/"
+    # @param body        [Hash, nil] Request body; serialised to JSON automatically
+    # @param query       [Hash]    Query-string parameters
+    # @param auth_header [String, nil] Override the Authorization header value
+    #
+    # @return [Hash] Parsed JSON response body
+    def request(method, path, body: nil, query: {}, auth_header: nil)
+      uri = build_uri(path, query)
+
+      attempts = 0
+      delay    = @retry_delay
+
+      begin
+        attempts += 1
+        response = execute(uri, method, body, auth_header)
+        handle_response(response)
+      rescue RateLimitError => e
+        # Respect Retry-After if present; always retry rate-limit errors up to max_retries
+        if attempts <= @max_retries
+          wait = e.retry_after || delay
+          sleep(wait)
+          delay *= 2
+          retry
+        end
+        raise
+      rescue ScreenshotFreeAPIError => e
+        # Retry 5xx errors with exponential backoff
+        if e.status_code.to_i >= 500 && attempts <= @max_retries
+          sleep(delay)
+          delay *= 2
+          retry
+        end
+        raise
+      end
+    end
+
+    private
+
+    # Build a URI object from the base URL, path, and optional query params.
+    def build_uri(path, query)
+      url = "#{@base_url}#{path}"
+      uri = URI.parse(url)
+
+      unless query.nil? || query.empty?
+        params = query.map { |k, v| "#{URI.encode_www_form_component(k.to_s)}=#{URI.encode_www_form_component(v.to_s)}" }
+        uri.query = params.join("&")
+      end
+
+      uri
+    end
+
+    # Execute a single HTTP call and return the Net::HTTP response object.
+    def execute(uri, method, body, auth_header)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                          open_timeout: @timeout,
+                                          read_timeout: @timeout) do |http|
+        req = build_request(method, uri, body, auth_header)
+        http.request(req)
+      end
+    end
+
+    # Instantiate the correct Net::HTTP request class and set headers/body.
+    def build_request(method, uri, body, auth_header)
+      klass = case method
+              when :get    then Net::HTTP::Get
+              when :post   then Net::HTTP::Post
+              when :patch  then Net::HTTP::Patch
+              when :delete then Net::HTTP::Delete
+              when :put    then Net::HTTP::Put
+              else raise ArgumentError, "Unsupported HTTP method: #{method}"
+              end
+
+      req = klass.new(uri.request_uri)
+      # auth_header: nil  => use default API key Bearer token
+      # auth_header: ""   => omit the Authorization header (public endpoints)
+      # auth_header: "Bearer <jwt>" => use the supplied value as-is
+      if auth_header.nil?
+        req["Authorization"] = "Bearer #{@api_key}"
+      elsif !auth_header.empty?
+        req["Authorization"] = auth_header
+      end
+      req["Content-Type"]  = "application/json"
+      req["Accept"]        = "application/json"
+      req["User-Agent"]    = "screenshotfreeapi-ruby/#{ScreenshotFreeAPI::VERSION}"
+
+      if body
+        req.body = JSON.generate(body)
+      end
+
+      req
+    end
+
+    # Parse the HTTP response and raise typed errors for non-2xx statuses.
+    def handle_response(response)
+      status = response.code.to_i
+      body   = parse_body(response.body)
+
+      return body if status >= 200 && status < 300
+
+      # Extract structured error info from the API's error envelope.
+      error_code = body.is_a?(Hash) ? (body["error"] || body["code"] || "UnknownError").to_s : "UnknownError"
+      message    = body.is_a?(Hash) ? (body["message"] || response.message || "Unknown error") : (response.message || "Unknown error")
+      details    = body.is_a?(Hash) ? body["details"] : nil
+
+      case status
+      when 400
+        raise ValidationError.new(message, details)
+      when 401
+        raise AuthenticationError.new(message)
+      when 402
+        raise PaymentRequiredError.new(message)
+      when 403
+        raise ForbiddenError.new(message)
+      when 404
+        raise NotFoundError.new(message)
+      when 429
+        retry_after_header = response["Retry-After"]
+        retry_after = retry_after_header ? retry_after_header.to_f : nil
+
+        if error_code == "QuotaExceeded"
+          raise QuotaExceededError.new(message)
+        else
+          raise RateLimitError.new(retry_after, message)
+        end
+      else
+        raise ScreenshotFreeAPIError.new(status, error_code, message, details)
+      end
+    end
+
+    # Attempt to parse a JSON response body; return raw string on failure.
+    def parse_body(raw)
+      return nil if raw.nil? || raw.empty?
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      raw
+    end
+  end
+end

data/lib/screenshotfreeapi/resources/auth.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ScreenshotFreeAPI
+  module Resources
+    # Authentication endpoints — registration, API key management, and JWT tokens.
+    #
+    # Note: `token` and `refresh` return JWTs that should be passed as the
+    # `jwt:` parameter to billing, workspace, and monitor resource methods.
+    class Auth
+      def initialize(http)
+        @http = http
+      end
+
+      # Register a new account.
+      #
+      # @param email    [String] User email address
+      # @param password [String] Password (min 8 chars on the server)
+      # @param name     [String] Display name
+      #
+      # @return [Hash] { "userId", "email", "apiKey" }
+      #   NOTE: apiKey is shown ONCE — store it securely.
+      def register(email:, password:, name:)
+        @http.request(:post, "/auth/register", body: {
+          email:    email,
+          password: password,
+          name:     name
+        })
+      end
+
+      # Obtain a management JWT by providing account credentials.
+      #
+      # The returned token is required for billing, workspace, and monitor
+      # endpoints. Pass it as `jwt:` to those resource methods.
+      #
+      # @param email    [String]
+      # @param password [String]
+      #
+      # @return [Hash] { "token", "expiresAt" }
+      def token(email:, password:)
+        @http.request(:post, "/auth/token", body: {
+          email:    email,
+          password: password
+        })
+      end
+
+      # Refresh an expired JWT using a refresh token.
+      #
+      # @param refresh_token [String] The refresh token from a previous `token` call
+      #
+      # @return [Hash] { "token", "expiresAt" }
+      def refresh(refresh_token:)
+        @http.request(:post, "/auth/refresh", body: {
+          refreshToken: refresh_token
+        })
+      end
+    end
+  end
+end

data/lib/screenshotfreeapi/resources/billing.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ScreenshotFreeAPI
+  module Resources
+    # Billing, plan, and subscription management.
+    #
+    # Most methods require a JWT (obtained via Auth#token) passed in the
+    # `jwt:` keyword argument. The client will send it as the Bearer token
+    # for that single request instead of the API key.
+    #
+    # The only exception is `plans`, which is publicly accessible.
+    class Billing
+      def initialize(http)
+        @http = http
+      end
+
+      # List all available subscription plans (no auth required).
+      #
+      # @return [Array<Hash>] Array of plan objects with name, price, limits, etc.
+      def plans
+        @http.request(:get, "/billing/plans", auth_header: "")
+      end
+
+      # Get the current user's active plan and usage summary.
+      #
+      # @param jwt [String] Management JWT from Auth#token
+      #
+      # @return [Hash] { "plan", "status", "screenshotsUsed", "screenshotsLimit", ... }
+      def plan(jwt:)
+        @http.request(:get, "/billing/plan", auth_header: "Bearer #{jwt}")
+      end
+
+      # Retrieve the 30-day daily usage history.
+      #
+      # @param jwt [String] Management JWT
+      #
+      # @return [Hash] { "usage" => Array of { "date", "count" } }
+      def usage(jwt:)
+        @http.request(:get, "/billing/usage", auth_header: "Bearer #{jwt}")
+      end
+
+      # Initiate a plan upgrade via Flutterwave checkout.
+      #
+      # @param jwt      [String] Management JWT
+      # @param plan     [String] Target plan tier: "STARTER" | "GROWTH" | "BUSINESS" | "ENTERPRISE"
+      # @param options  [Hash]   Additional upgrade options
+      #
+      # @return [Hash] { "checkoutUrl", "transactionRef" } — redirect user to checkoutUrl
+      def upgrade(jwt:, plan:, **options)
+        body = { plan: plan }.merge(options)
+        @http.request(:post, "/billing/upgrade", body: body, auth_header: "Bearer #{jwt}")
+      end
+
+      # Server-side verification of a completed Flutterwave payment.
+      #
+      # Call this after the user returns from the Flutterwave checkout redirect.
+      #
+      # @param jwt              [String] Management JWT
+      # @param transaction_ref  [String] The transactionRef from `upgrade`
+      #
+      # @return [Hash] { "success", "plan", "message" }
+      def verify(jwt:, transaction_ref: nil)
+        query = transaction_ref ? { transaction_ref: transaction_ref } : {}
+        @http.request(:get, "/billing/verify", query: query, auth_header: "Bearer #{jwt}")
+      end
+
+      # Cancel the active subscription.
+      #
+      # @param jwt [String] Management JWT
+      #
+      # @return [Hash] { "message", "effectiveAt" }
+      def cancel(jwt:)
+        @http.request(:post, "/billing/cancel", body: {}, auth_header: "Bearer #{jwt}")
+      end
+    end
+  end
+end

data/lib/screenshotfreeapi/resources/integrations.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ScreenshotFreeAPI
+  module Resources
+    # Third-party integration endpoints.
+    #
+    # Currently supports Zapier REST Hooks for no-code workflow automation.
+    # All methods use API key authentication (no JWT required).
+    class Integrations
+      def initialize(http)
+        @http = http
+      end
+
+      # Register a Zapier webhook subscription (REST Hook subscribe).
+      #
+      # Zapier calls this endpoint when a Zap is turned on. You can also call
+      # it directly to register any webhook for screenshot-complete events.
+      #
+      # @param target_url   [String] URL Zapier will POST events to
+      # @param event        [String] Event type to subscribe to, e.g. "screenshot.completed"
+      # @param options      [Hash]   Additional subscription options
+      #
+      # @return [Hash] { "id", "targetUrl", "event", "createdAt" }
+      def zapier_subscribe(target_url:, event:, **options)
+        body = { targetUrl: target_url, event: event }.merge(options)
+        @http.request(:post, "/integrations/zapier/subscribe", body: body)
+      end
+
+      # Unregister a Zapier webhook subscription (REST Hook unsubscribe).
+      #
+      # Zapier calls this when the Zap is turned off.
+      #
+      # @param subscription_id [String] ID returned by `zapier_subscribe`
+      #
+      # @return [Hash] Confirmation object
+      def zapier_unsubscribe(subscription_id:)
+        @http.request(:delete, "/integrations/zapier/unsubscribe/#{subscription_id}")
+      end
+
+      # Retrieve a sample payload for a Zapier trigger event.
+      #
+      # Zapier uses this to show users a preview of the data they can map in their Zap.
+      #
+      # @param event [String] Event type, e.g. "screenshot.completed"
+      #
+      # @return [Array<Hash>] Array of sample event payloads (Zapier polling format)
+      def zapier_triggers(event:)
+        @http.request(:get, "/integrations/zapier/triggers/#{event}")
+      end
+    end
+  end
+end

data/lib/screenshotfreeapi/resources/jobs.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ScreenshotFreeAPI
+  module Resources
+    # Job polling endpoints.
+    #
+    # All screenshot requests are asynchronous — the POST endpoints return a
+    # jobId immediately. Use these methods to check progress and retrieve
+    # results once the job reaches the "completed" state.
+    class Jobs
+      def initialize(http)
+        @http = http
+      end
+
+      # Retrieve the current status of a job.
+      #
+      # @param job_id [String] The jobId returned by a screenshot POST
+      #
+      # @return [Hash]
+      #   {
+      #     "jobId"            => String,
+      #     "status"           => "queued" | "processing" | "completed" | "failed",
+      #     "progress"         => Integer (0-100),
+      #     "error"            => String | nil,
+      #     "estimatedSeconds" => Integer | nil,
+      #     "createdAt"        => String (ISO 8601),
+      #     "updatedAt"        => String (ISO 8601)
+      #   }
+      def status(job_id)
+        @http.request(:get, "/jobs/#{job_id}/status")
+      end
+
+      # Retrieve the completed result of a job.
+      #
+      # Only available once `status` returns "completed". Raises NotFoundError
+      # if the job is not yet done or was not found.
+      #
+      # @param job_id [String]
+      #
+      # @return [Hash]
+      #   {
+      #     "jobId"       => String,
+      #     "type"        => "web" | "mobile" | "html",
+      #     "screenshots" => Array of {
+      #       "url"        => String (presigned S3 URL, 15-min TTL),
+      #       "format"     => "png" | "jpeg" | "webp" | "pdf",
+      #       "width"      => Integer,
+      #       "height"     => Integer,
+      #       "capturedAt" => String,
+      #       "selector"   => String | nil
+      #     },
+      #     "metadata"    => Hash (AI info, processingMs, etc.)
+      #   }
+      def result(job_id)
+        @http.request(:get, "/jobs/#{job_id}/result")
+      end
+    end
+  end
+end

data/lib/screenshotfreeapi/resources/monitors.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ScreenshotFreeAPI
+  module Resources
+    # App monitoring — schedule recurring captures and receive diff alerts.
+    #
+    # Monitors run on a cron schedule and alert you when an app's screenshots
+    # change (e.g., new version, UI refresh). Requires a BUSINESS+ plan.
+    #
+    # All methods require a management JWT passed as `jwt:`.
+    class Monitors
+      def initialize(http)
+        @http = http
+      end
+
+      # Create a new app monitor.
+      #
+      # @param jwt         [String] Management JWT
+      # @param app_name    [String] App display name to monitor
+      # @param platform    [String] "ios" | "android" | "both"
+      # @param schedule    [String] Cron expression, e.g. "0 9 * * *" (daily at 9 AM UTC)
+      # @param webhook_url [String] URL to notify on detected changes
+      # @param options     [Hash]   Additional monitor options
+      #
+      # @return [Hash] Monitor object with "id", "appName", "platform", "schedule"
+      def create(jwt:, app_name:, platform:, schedule:, webhook_url: nil, **options)
+        body = {
+          appName:    app_name,
+          platform:   platform,
+          schedule:   schedule,
+          webhookUrl: webhook_url
+        }.compact.merge(options)
+
+        @http.request(:post, "/monitors/app", body: body, auth_header: "Bearer #{jwt}")
+      end
+
+      # List all monitors for the authenticated user.
+      #
+      # @param jwt [String] Management JWT
+      #
+      # @return [Array<Hash>] Array of monitor objects
+      def list(jwt:)
+        @http.request(:get, "/monitors/app", auth_header: "Bearer #{jwt}")
+      end
+
+      # Get a single monitor's details.
+      #
+      # @param jwt        [String] Management JWT
+      # @param monitor_id [String] Monitor ID
+      #
+      # @return [Hash] Monitor object
+      def get(jwt:, monitor_id:)
+        @http.request(:get, "/monitors/app/#{monitor_id}", auth_header: "Bearer #{jwt}")
+      end
+
+      # Delete a monitor.
+      #
+      # @param jwt        [String] Management JWT
+      # @param monitor_id [String] Monitor ID
+      #
+      # @return [Hash] Confirmation object
+      def delete(jwt:, monitor_id:)
+        @http.request(:delete, "/monitors/app/#{monitor_id}", auth_header: "Bearer #{jwt}")
+      end
+
+      # Retrieve the run history and diff results for a monitor.
+      #
+      # @param jwt        [String] Management JWT
+      # @param monitor_id [String] Monitor ID
+      # @param limit      [Integer] Number of history entries to return (optional)
+      # @param offset     [Integer] Pagination offset (optional)
+      #
+      # @return [Hash] { "history" => Array of run result hashes }
+      def history(jwt:, monitor_id:, limit: nil, offset: nil)
+        query = {}
+        query[:limit]  = limit  if limit
+        query[:offset] = offset if offset
+
+        @http.request(
+          :get,
+          "/monitors/app/#{monitor_id}/history",
+          query:       query,
+          auth_header: "Bearer #{jwt}"
+        )
+      end
+    end
+  end
+end

data/lib/screenshotfreeapi/resources/screenshots.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module ScreenshotFreeAPI
+  module Resources
+    # Screenshot capture endpoints with optional synchronous polling helpers.
+    #
+    # All `web`, `mobile`, and `html` methods return a 202 job receipt.
+    # The `*_and_wait` variants block until the job completes and return the
+    # full result hash directly.
+    class Screenshots
+      # @param http   [HttpClient]
+      def initialize(http)
+        @http = http
+      end
+
+      # Enqueue a web screenshot job.
+      #
+      # @param url             [String]  Required. Public URL to capture.
+      # @param description     [String]  Plain-English description of the element
+      #                                  to target (triggers AI vision path).
+      # @param element         [String]  CSS selector to capture instead of full page.
+      # @param dimensions      [Hash]    { width: Integer, height: Integer }
+      # @param full_page       [Boolean] Capture the entire scrollable page.
+      # @param scrolling       [Boolean] Enable scroll-based capture.
+      # @param format          [String]  "png" | "jpeg" | "webp" | "pdf"  (default: "png")
+      # @param paper_size      [String]  PDF paper size, e.g. "A4", "Letter"
+      # @param block_ads       [Boolean] Block ad scripts before capture (STARTER+)
+      # @param accept_cookies  [Boolean] Auto-dismiss cookie banners (STARTER+)
+      # @param stealth         [Boolean] Enable stealth mode (BUSINESS+)
+      # @param proxy_location  [String]  Proxy region, e.g. "eu-west" (BUSINESS+)
+      # @param video           [Hash]    { duration: Integer, fps: Integer } (GROWTH+)
+      # @param bypass_cache    [Boolean] Skip the response cache.
+      # @param storage         [Hash]    Custom S3 config (BUSINESS+)
+      # @param webhook_url     [String]  URL to POST completion event to.
+      #
+      # @return [Hash] { "jobId", "status", "statusUrl", "estimatedSeconds" }
+      def web(options = {})
+        @http.request(:post, "/screenshots/web", body: camelize_keys(options))
+      end
+
+      # Enqueue a mobile app screenshot job.
+      #
+      # @param app_name             [String]  App display name (e.g. "Instagram")
+      # @param platform             [String]  "ios" | "android" | "both"
+      # @param bundle_id            [String]  Bundle/package ID
+      # @param include_store_listing [Boolean] Also download store listing images
+      # @param device_emulation     [String]  Playwright device preset (e.g. "iPhone 12")
+      # @param webhook_url          [String]
+      #
+      # @return [Hash] { "jobId", "status", "statusUrl", "estimatedSeconds" }
+      def mobile(options = {})
+        @http.request(:post, "/screenshots/mobile", body: camelize_keys(options))
+      end
+
+      # Enqueue an HTML-string screenshot job.
+      #
+      # @param html         [String]  Raw HTML to render and capture.
+      # @param dimensions   [Hash]    { width: Integer, height: Integer }
+      # @param full_page    [Boolean]
+      # @param format       [String]  "png" | "jpeg" | "webp" | "pdf"
+      # @param webhook_url  [String]
+      #
+      # @return [Hash] { "jobId", "status", "statusUrl", "estimatedSeconds" }
+      def html(options = {})
+        @http.request(:post, "/screenshots/html", body: camelize_keys(options))
+      end
+
+      # Capture a web screenshot and block until it completes.
+      #
+      # Combines `web` + `wait` in a single call.
+      #
+      # @param options       [Hash]    Same keyword arguments as `web`.
+      # @param poll_interval [Numeric] Seconds between status polls (default: 2)
+      # @param timeout       [Numeric] Maximum seconds to wait (default: 120)
+      # @yieldparam status   [Hash]    Called on each poll with the current status hash.
+      #
+      # @return [Hash] Full result hash (same as Jobs#result)
+      def web_and_wait(options = {}, poll_interval: 2, timeout: 120, &on_progress)
+        job = web(options)
+        wait(job["jobId"], poll_interval: poll_interval, timeout: timeout, &on_progress)
+      end
+
+      # Capture a mobile screenshot and block until it completes.
+      #
+      # @param options       [Hash]    Same keyword arguments as `mobile`.
+      # @param poll_interval [Numeric]
+      # @param timeout       [Numeric]
+      #
+      # @return [Hash] Full result hash
+      def mobile_and_wait(options = {}, poll_interval: 2, timeout: 120)
+        job = mobile(options)
+        wait(job["jobId"], poll_interval: poll_interval, timeout: timeout)
+      end
+
+      # Render an HTML string and block until the screenshot is ready.
+      #
+      # @param options       [Hash]    Same keyword arguments as `html`.
+      # @param poll_interval [Numeric]
+      # @param timeout       [Numeric]
+      #
+      # @return [Hash] Full result hash
+      def html_and_wait(options = {}, poll_interval: 2, timeout: 120)
+        job = html(options)
+        wait(job["jobId"], poll_interval: poll_interval, timeout: timeout)
+      end
+
+      # Poll a job until it reaches a terminal state.
+      #
+      # @param job_id        [String]
+      # @param poll_interval [Numeric] Seconds between status polls (default: 2)
+      # @param timeout       [Numeric] Maximum seconds to wait (default: 120)
+      # @yieldparam status   [Hash]    Called on each poll (optional progress callback)
+      #
+      # @return [Hash] Full result hash (from /jobs/:id/result)
+      # @raise  [JobFailedError]   If the job transitions to "failed"
+      # @raise  [JobTimeoutError]  If the job does not complete within `timeout` seconds
+      def wait(job_id, poll_interval: 2, timeout: 120, &on_progress)
+        deadline = Time.now + timeout
+
+        loop do
+          status_data = @http.request(:get, "/jobs/#{job_id}/status")
+
+          on_progress.call(status_data) if on_progress
+
+          case status_data["status"]
+          when "completed"
+            return @http.request(:get, "/jobs/#{job_id}/result")
+          when "failed"
+            reason = status_data["error"] || "Unknown failure"
+            raise JobFailedError.new(job_id, reason)
+          end
+
+          if Time.now >= deadline
+            raise JobTimeoutError.new(job_id, timeout)
+          end
+
+          sleep(poll_interval)
+        end
+      end
+
+      private
+
+      # Convert Ruby snake_case keys to camelCase for the JSON API.
+      # Nested hashes and arrays are recursively converted.
+      def camelize_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(k, v), memo|
+            camel_key = snake_to_camel(k.to_s)
+            memo[camel_key] = camelize_keys(v)
+          end
+        when Array
+          obj.map { |item| camelize_keys(item) }
+        else
+          obj
+        end
+      end
+
+      # "some_key_name" => "someKeyName"
+      def snake_to_camel(str)
+        parts = str.split("_")
+        parts[0] + parts[1..].map(&:capitalize).join
+      end
+    end
+  end
+end