perata-sdk 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 64384c4af37e5af51b1adea727b0475da68c843b5c25aedb6392bd3b3cd4bc8a
+  data.tar.gz: b87c39face8ac30151097de8cc07b5be89787420501ea236afc5f4d875f77348
+SHA512:
+  metadata.gz: 2cc402f3ac1361b6eaa815bc97615c7d0754486b677fe930623e83a5c7b73f454dd348b6b9f3a942ff235d42e84512580f6ad29fd9af31757cace6f1094fb62c
+  data.tar.gz: 497bec18e6a4a0b4d1f2fd1a7aeccb289877a2cd638d8a8297008d07fd86b0d87b276a3e193532a8160a4f774418dd4da51fd4ce497c58ea554673ef04af6385

data/README.md

@@ -0,0 +1,51 @@
+# Peráta SDK para Ruby
+
+SDK oficial da API da Peráta para Ruby 3.1+, sem dependências: só `net/http`, `json` e `openssl`. É gerado a partir do contrato da API (`openapi.json`, na raiz de [perata-sh/sdk](https://github.com/perata-sh/sdk)) por `generator/`. Não edite os arquivos desta pasta: regenere.
+
+```sh
+gem install perata-sdk
+```
+
+```ruby
+require "perata"
+
+perata = Perata::Client.new(ENV.fetch("PERATA_API_KEY")) # prk_test_… ou prk_live_…
+
+product = perata.products.create({ name: "Curso" }, idempotency_key: "produto-curso")
+
+perata.products.list_iter.each do |product|
+  puts product.name
+end
+```
+
+## Recursos
+
+| Serviço | Métodos |
+|---|---|
+| `perata.checkouts` | `create` |
+| `perata.customers` | `create`, `get`, `list`, `list_iter` |
+| `perata.orders` | `list`, `list_iter` |
+| `perata.payment_methods` | `detach`, `list`, `list_iter` |
+| `perata.payments` | `get`, `list`, `list_iter` |
+| `perata.prices` | `create`, `list`, `list_iter` |
+| `perata.products` | `create`, `get`, `list`, `list_iter` |
+| `perata.refunds` | `create` |
+| `perata.subscriptions` | `cancel`, `get`, `list`, `list_iter` |
+
+Os modelos são objetos imutáveis com leitores em snake_case (`payment.amount_cents`). O corpo de uma escrita é a classe de parâmetros do método (`Perata::ProductsCreateParams.new(name: "Curso")`) ou um `Hash` com os mesmos nomes; um campo opcional não informado fica fora do JSON. Os métodos `_iter` devolvem um `Enumerator` que percorre todas as páginas a partir de `page:` (ou recebem um bloco).
+
+As escritas aceitam `idempotency_key:`, e todas aceitam `api_key:` para usar a chave de outra organização numa chamada. `Perata::Client.new` aceita `base_url:`, `timeout:` (30 segundos) e `transport:`.
+
+## Erros
+
+Uma recusa da API levanta `Perata::Error`, com `status`, `code` (`invalid_request`, `not_found`…), `message`, `fields` (o problema de cada campo) e, num 429, `retry_after` em segundos.
+
+## Webhooks
+
+```ruby
+event = Perata.verify_webhook(ENV.fetch("PERATA_WEBHOOK_SECRET"), request.headers, request.raw_post)
+```
+
+A assinatura é a do Standard Webhooks (`webhook-id`, `webhook-timestamp`, `webhook-signature`), com tolerância de 5 minutos. Passe o corpo cru, antes de interpretar; os cabeçalhos podem vir num `Hash` ou no env do Rack. Uma assinatura que não confere levanta `Perata::WebhookVerificationError`.
+
+Versão do SDK: 0.1.1 · contrato da API: 0.1.0

data/lib/perata/client.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Code generated by sdk/generator. DO NOT EDIT.
+
+require "json"
+require "net/http"
+require "uri"
+
+module Perata
+  # The standard library's HTTP, so the SDK depends on nothing. A transport is
+  # anything that answers +call(method, url, headers, body, timeout)+ with
+  # +[status, headers in lower case, body]+.
+  class NetHTTPTransport
+    def call(method, url, headers, body, timeout)
+      uri = URI(url)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                          open_timeout: timeout, read_timeout: timeout, write_timeout: timeout) do |http|
+        response = http.send_request(method, uri.request_uri, body, headers)
+        [response.code.to_i, response.each_header.to_h, response.body.to_s]
+      end
+    end
+  end
+
+  # Peráta's API with one organization's API key.
+  #
+  # The key says the organization and the environment: +prk_test_…+ is the
+  # test environment, +prk_live_…+ the live one.
+  #
+  #   perata = Perata::Client.new(ENV.fetch("PERATA_API_KEY"))
+  #   product = perata.products.create({ name: "Curso" })
+  #   perata.products.list_iter { |product| puts product.name }
+  class Client
+    # @return [CheckoutsService]
+    attr_reader :checkouts
+    # @return [CustomersService]
+    attr_reader :customers
+    # @return [OrdersService]
+    attr_reader :orders
+    # @return [PaymentMethodsService]
+    attr_reader :payment_methods
+    # @return [PaymentsService]
+    attr_reader :payments
+    # @return [PricesService]
+    attr_reader :prices
+    # @return [ProductsService]
+    attr_reader :products
+    # @return [RefundsService]
+    attr_reader :refunds
+    # @return [SubscriptionsService]
+    attr_reader :subscriptions
+
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, timeout: 30, transport: NetHTTPTransport.new)
+      @api_key = api_key
+      @base_url = base_url.chomp("/")
+      @timeout = timeout
+      @transport = transport
+      @checkouts = CheckoutsService.new(self)
+      @customers = CustomersService.new(self)
+      @orders = OrdersService.new(self)
+      @payment_methods = PaymentMethodsService.new(self)
+      @payments = PaymentsService.new(self)
+      @prices = PricesService.new(self)
+      @products = ProductsService.new(self)
+      @refunds = RefundsService.new(self)
+      @subscriptions = SubscriptionsService.new(self)
+    end
+
+    # Calls the API and answers what it wrapped in +data+; a refusal raises
+    # Perata::Error.
+    def request(method, path, query: nil, body: nil, idempotency_key: nil, api_key: nil)
+      url = @base_url + path
+      values = (query || {}).reject { |_, value| value.nil? || value == "" }
+      url += "?#{URI.encode_www_form(values)}" unless values.empty?
+      headers = {
+        "Authorization" => "Bearer #{api_key.nil? || api_key.empty? ? @api_key : api_key}",
+        "Accept" => "application/json",
+        "User-Agent" => "perata-ruby/#{VERSION}"
+      }
+      data = nil
+      unless body.nil?
+        data = JSON.generate(body)
+        headers["Content-Type"] = "application/json"
+      end
+      headers["Idempotency-Key"] = idempotency_key if idempotency_key && !idempotency_key.empty?
+      status, response_headers, raw = @transport.call(method, url, headers, data, @timeout)
+      raise Error.from_response(status, response_headers, raw) if status >= 300
+
+      JSON.parse(raw).fetch("data")
+    end
+  end
+end

data/lib/perata/error.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Perata
+  # A request the API refused.
+  #
+  # +code+ is the API's: invalid_credential, forbidden, not_found,
+  # invalid_request, conflict, idempotency_conflict, body_too_large or
+  # unavailable. +message+ is the API's explanation, +fields+ says, for
+  # invalid_request, what is wrong with each field, and +retry_after+ is how
+  # many seconds to wait on a 429.
+  class Error < StandardError
+    attr_reader :status, :code, :message, :fields, :retry_after
+
+    def initialize(status, code, message = "", fields = {}, retry_after = nil)
+      @status = status
+      @code = code
+      @message = message
+      @fields = fields
+      @retry_after = retry_after
+      super(message.empty? ? "perata: #{status} #{code}" : "perata: #{status} #{code}: #{message}")
+    end
+
+    # What Ruby prints for an error nobody rescued: the status and code too.
+    def detailed_message(highlight: false, **)
+      highlight ? "\e[1m#{self} (#{self.class.name})\e[m" : "#{self} (#{self.class.name})"
+    end
+
+    # The error a response with a status of 300 or more is.
+    def self.from_response(status, headers, body)
+      data = begin
+        loaded = JSON.parse(body.to_s.empty? ? "{}" : body)
+        loaded.is_a?(Hash) ? loaded : {}
+      rescue JSON::ParserError
+        {} # A refusal without a JSON body is still a refusal.
+      end
+      retry_after = headers["retry-after"].to_s
+      new(status, data["error"].to_s, data["message"].to_s, data["fields"] || {},
+          retry_after.match?(/\A\d+\z/) ? retry_after.to_i : nil)
+    end
+  end
+end

data/lib/perata/model.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Perata
+  # What every resource and every body shares: its members, read as a hash and
+  # compared by value.
+  module Value
+    def to_h
+      self.class::MEMBERS.to_h { |name| [name, instance_variable_get(:"@#{name}")] }
+    end
+
+    def ==(other)
+      other.class == self.class && other.to_h == to_h
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, to_h].hash
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_h.map { |name, value| "#{name}=#{value.inspect}" }.join(", ")}>"
+    end
+    alias to_s inspect
+  end
+
+  # A resource the API answers, built from its JSON and frozen.
+  class Model
+    include Value
+  end
+
+  # The body of a write: built with keyword arguments, sent with the API's
+  # names, an optional field left unset left out.
+  class Params
+    include Value
+
+    # The params as they are, or built from a hash of their names.
+    def self.coerce(params)
+      case params
+      when self then params
+      when Hash then new(**params.transform_keys(&:to_sym))
+      else raise ArgumentError, "perata: #{name} is built from a Hash, not #{params.class}"
+      end
+    end
+  end
+end