wenmar 0.8.0

data/lib/wenmar/error.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Wenmar
+  class Error < StandardError
+    attr_reader :code, :message, :field_errors, :status, :request_id
+
+    def initialize(code:, message:, field_errors: {}, status: nil, request_id: nil)
+      @code = code
+      @message = message
+      @field_errors = field_errors
+      @status = status
+      @request_id = request_id
+      super("#{code}: #{message} (HTTP #{status})")
+    end
+
+    def self.from_response(response)
+      body = response.body
+      headers = response.respond_to?(:headers) ? (response.headers || {}) : {}
+
+      # Empty bodies can't be parsed; fall back to the status code so callers
+      # still get a meaningful error when the server omits the error envelope.
+      if body.nil? || (body.is_a?(String) && body.strip.empty?)
+        if (fallback = fallback_code_for_status(response.status))
+          return new(code: fallback, message: "HTTP #{response.status}", status: response.status, request_id: headers["X-Request-Id"])
+        end
+        return new(code: "unknown", message: "HTTP #{response.status} with empty body", status: response.status)
+      end
+
+      body = JSON.parse(body) if body.is_a?(String)
+      body = {} unless body.is_a?(Hash)
+
+      if body["error"].is_a?(Hash)
+        err = body["error"]
+        new(
+          code: err["code"] || "unknown",
+          message: err["message"] || "API error",
+          field_errors: field_errors_map(err["field_errors"] || err["details"] || {}),
+          status: response.status,
+          request_id: headers["X-Request-Id"]
+        )
+      elsif (fallback = fallback_code_for_status(response.status))
+        new(code: fallback, message: "HTTP #{response.status}", status: response.status, request_id: headers["X-Request-Id"])
+      else
+        new(code: "unknown", message: body.to_s, status: response.status)
+      end
+    rescue JSON::ParserError
+      new(code: "unknown", message: "Malformed error response", status: response.status)
+    end
+
+    def self.fallback_code_for_status(status)
+      {
+        401 => "unauthorized",
+        403 => "forbidden",
+        404 => "not_found",
+        409 => "conflict",
+        422 => "validation_failed",
+        429 => "rate_limited",
+        500 => "internal_error",
+        502 => "bad_gateway",
+        503 => "service_unavailable",
+        504 => "gateway_timeout",
+        507 => "limit_exceeded"
+      }[status]
+    end
+
+    def self.field_errors_map(list)
+      case list
+      when Hash
+        list
+      when Array
+        list.each_with_object({}) do |item, memo|
+          if item.is_a?(Hash)
+            memo[item["field"] || item[:field]] = item["message"] || item[:message]
+          end
+        end
+      else
+        {}
+      end
+    end
+
+    # Extracts validation field errors from the field_errors hash.
+    # The Wenmar API sends: field_errors: { "first_name" => ["can't be blank"] }
+    # Returns nil if there are no field errors.
+    def field_errors_by_field
+      return nil if @field_errors.nil? || @field_errors.empty?
+
+      result = {}
+      @field_errors.each do |field, raw|
+        case raw
+        when Array
+          msgs = raw.map(&:to_s)
+          result[field] = msgs if msgs.any?
+        when String
+          result[field] = [raw]
+        end
+      end
+      result.empty? ? nil : result
+    end
+
+    # Reports whether the error is worth retrying.
+    def retryable?
+      return true if @code == "rate_limited"
+      return false if @code == "limit_exceeded"
+
+      @status >= 500 && @status != 507
+    end
+  end
+end

data/lib/wenmar/oauth.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "uri"
+
+module Wenmar
+  module OAuth
+    DEFAULT_CLIENT_ID = "wenmar-cli"
+
+    # POSTs a refresh_token grant to the Doorkeeper token endpoint and returns
+    # a fresh Wenmar::Token. Redirects are not followed: a 3xx from the token
+    # endpoint is a security risk, not a redirect to follow.
+    def self.refresh(base_url:, refresh_token:, client_id: DEFAULT_CLIENT_ID)
+      endpoint = "#{base_url.to_s.sub(%r{/+\z}, "")}/oauth/token"
+
+      conn = Faraday.new(url: endpoint) do |f|
+        f.options.timeout = 10
+        f.adapter Faraday.default_adapter
+      end
+
+      response = conn.post do |req|
+        req.headers["Content-Type"] = "application/x-www-form-urlencoded"
+        req.headers["Accept"] = "application/json"
+        req.body = URI.encode_www_form({grant_type: "refresh_token", client_id: client_id, refresh_token: refresh_token})
+      end
+
+      unless response.success?
+        error = begin
+          JSON.parse(response.body)["error"]
+        rescue
+          nil
+        end
+        message = error ? "token refresh failed: #{error}" : "token refresh failed: HTTP #{response.status}"
+        raise TokenError, message
+      end
+
+      data = JSON.parse(response.body)
+      if data["access_token"].nil? || data["access_token"].empty?
+        raise TokenError, "refresh response missing access_token"
+      end
+
+      Token.new(
+        access_token: data["access_token"],
+        refresh_token: data["refresh_token"],
+        expires_at: data["expires_in"] ? Time.now + data["expires_in"].to_i : nil,
+        token_type: data["token_type"] || "Bearer"
+      )
+    rescue JSON::ParserError => e
+      raise TokenError, "parse refresh response: #{e.message}"
+    end
+  end
+end

data/lib/wenmar/pagination.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Wenmar
+  class Paginator
+    include Enumerable
+
+    attr_reader :data, :links, :meta, :next_url, :client
+
+    def initialize(client, page)
+      @client = client
+      @data = page.fetch("data", page.fetch(:data, []))
+      @links = page.fetch("links", page.fetch(:links, {}))
+      @meta = page.fetch("meta", page.fetch(:meta, {}))
+      @page = page
+      @next_url = @links["next"] || @links[:next]
+    end
+
+    def has_next?
+      !@next_url.nil? && !@next_url.empty?
+    end
+
+    def next_page
+      return nil unless has_next?
+
+      unless same_origin?(@next_url, @client.base_url)
+        raise Wenmar::Error.new(
+          code: "invalid_pagination",
+          message: "pagination next URL is not same-origin as base URL",
+          field_errors: {},
+          status: 0
+        )
+      end
+
+      response = @client.send(:get_raw, @next_url)
+      @next_url = self.class.parse_link_header(response.headers["Link"], "next")
+      JSON.parse(response.body)
+    end
+
+    def each
+      return to_enum unless block_given?
+
+      page = self
+      loop do
+        page.data.each { |item| yield item }
+        page = page.next_page
+        break if page.nil?
+      end
+    end
+
+    def to_a(max = 1000)
+      result = []
+      page = self
+      loop do
+        result.concat(page.data)
+        break if result.size >= max
+
+        page = page.next_page
+        break if page.nil?
+      end
+      result.first(max)
+    end
+
+    def same_origin?(url, base_url)
+      parsed = URI.parse(url)
+      base = URI.parse(base_url)
+      parsed.scheme == base.scheme && parsed.host == base.host && parsed.port == base.port
+    rescue URI::InvalidURIError
+      false
+    end
+    private :same_origin?
+
+    def self.parse_link_header(header, rel)
+      return nil if header.nil? || header.empty?
+
+      header.split(",").each do |part|
+        match = part.match(/<([^>]+)>;\s*rel="#{rel}"/)
+        return match[1] if match
+      end
+      nil
+    end
+
+    def self.from_response(response, client)
+      link_header = response.headers["Link"]
+      next_url = parse_link_header(link_header, "next")
+      new(client, {"data" => [], "links" => {"next" => next_url}, "meta" => {}})
+    end
+  end
+end