saby_vok 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e374ddcc4a44ce5055e3c26e18e3d92ca52beaa1756ee4705f913a4ee072f2a5
+  data.tar.gz: 5a2ec3eefda6a8c638a580ef30eb5c2d7f3d59f6fd7a6f8e2d81aa398d63ed80
+SHA512:
+  metadata.gz: 46fb949f502e8e50547606e50f52c53845727de8ee5b071314c4502d94b6626713339e82ad4e33aa97410784062dc18c82f6419023553a51fc43e450ab9f55a0
+  data.tar.gz: 742120a6bc645d09a0f28b66b2350032571e2b7ce345a18797d33354779195a1726cce27b29279d67e001b42382762ffe0d9943b587ff6f93cbf17bd4120efe8

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+- Начальный релиз: аутентификация через сервисные токены, JSON и бинарные запросы, методы покрывают публичный перечень API.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vitalii Dementev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+# Saby Vok Ruby Client
+
+**saby_vok** - Ruby-клиент для API «Всё о компаниях» (СБИС). Библиотека сама выполняет сервисную авторизацию, автоматически обновляет токены при 401/403, проставляет заголовки `X-SBISAccessToken` и `X-SBISSessionId`, а также умеет работать с JSON и бинарными ответами.
+
+## Требования
+
+- Ruby >= 3.1
+- Действующие `client_id`, `client_secret`, `secret_key` в личном кабинете СБИС
+
+## Установка
+
+Через Bundler:
+
+```ruby
+gem "saby_vok"
+```
+
+или командой:
+
+```bash
+bundle add saby_vok
+```
+
+Без Bundler:
+
+```bash
+gem install saby_vok
+```
+
+После установки подключите библиотеку:
+
+```ruby
+require "saby_vok"
+```
+
+## Быстрый старт
+
+```ruby
+require "saby_vok"
+
+client = SabyVok::Client.new(
+  ENV.fetch("SABY_CLIENT_ID"),
+  ENV.fetch("SABY_CLIENT_SECRET"),
+  ENV.fetch("SABY_SECRET_KEY")
+)
+
+companies = client.req(inn: "7605016030")
+puts companies.first["company_name"]
+```
+
+Бинарные ответы сохраняйте как есть:
+
+```ruby
+File.binwrite("logo.png", client.logo(inn: "7605016030"))
+```
+
+## Обработка ошибок
+
+```ruby
+begin
+  client.req
+rescue SabyVok::ValidationError => e
+  warn "wrong params: #{e.message}"
+rescue SabyVok::AuthError => e
+  warn "auth failed: #{e.message}"
+rescue SabyVok::HttpError => e
+  warn "http #{e.status}: #{e.body}"
+end
+```
+
+## Конфигурация и синглтон
+
+```ruby
+SabyVok.configure do |config|
+  config.client_id = ENV.fetch("SABY_CLIENT_ID")
+  config.client_secret = ENV.fetch("SABY_CLIENT_SECRET")
+  config.secret_key = ENV.fetch("SABY_SECRET_KEY")
+  config.host = "https://api.sbis.ru/vok/"      # опционально
+  config.timeout = 10                           # секунды
+  config.retries = 2
+end
+
+client = SabyVok.client
+```
+
+Нужно обновить настройки - вызовите `SabyVok.reset_client!`, либо создавайте отдельные экземпляры `SabyVok::Client.new(...)` для разных проектов/хостов. Внутри используются мьютексы (`Mutex` и `Mutex_m`), поэтому загрузка токенов и доступ к `SabyVok.client` потокобезопасны.
+
+## Rails / Rack проекты
+
+```ruby
+# Gemfile
+gem "saby_vok"
+
+# config/initializers/saby_vok.rb
+SabyVok.configure do |config|
+  creds = Rails.application.credentials.fetch(:saby_vok)
+  config.client_id     = creds.fetch(:client_id)
+  config.client_secret = creds.fetch(:client_secret)
+  config.secret_key    = creds.fetch(:secret_key)
+end
+
+# anywhere in app
+SabyVok.client.req(inn: params[:inn])
+```
+
+## Поддерживаемые методы
+
+JSON:
+
+- `req`, `registration_information`, `tenders_info`, `tenders(limit:, page:)`
+- `finance`, `cost_business`, `reliability`, `reliability_blocks`, `market_position`, `creditworthiness`
+- `owners`, `affiliate`, `dirs_history`, `founders_history`
+- `license_stat`, `license_data`, `inspections_stat`, `inspections_data`
+- `statistic_courts`, `courts`, `executive_lists`, `bankruptcy`, `fea`
+- `subscriptions_events`, `subscriptions_contractors`, `subscribe`, `unsubscribe`
+- `contractor_history`, `contacts_official`, `branches`
+- `excerpts_list`, `excerpts_last`, `search`, `client_stat`
+- `trademarks`, `vehicle`, `vehicle_stat`, `pledges`
+
+Бинарные:
+
+- `logo`, `bankruptcy_file`, `events_file`
+- `sro_file`, `excerpts_file`, `trademarks_image`
+- `pdf_business_report`, `pdf_due_diligence_report`, `pdf_financial_report`, `pdf_signed_excerpt`
+- `xml_egrul_excerpt`, `xml_reporting_excerpt`
+- `pledges_file`, `tenders` документы
+
+## Ограничения API
+
+- Нужен хотя бы один из параметров: `inn` или `ogrn`.
+- `kpp` разрешён только вместе с `inn`.
+- Массовые запросы: до 20 значений одного типа (ИНН или ОГРН). Пары ИНН+КПП указывайте перед одиночными ИНН.
+- Пагинация: `limit > 0`, `page >= 0`.
+
+## Демо-окружение
+
+- Базовый URL демо: `https://api.sbis.ru/vok-demo/`.
+- Демо-ИНН: `7605016030`, `7736050003`, `7707049388`, `7814593627`, `7827004484`, `772871281410`, `6382082839`, `7708503727`, `7709464710`.
+- В демо отключены методы, возвращающие файлы.
+
+## Разработка
+
+```bash
+bundle install
+rake test
+rubocop
+```
+
+Пулы и багрепорты приветствуются в [issues](https://github.com/DementevVV/saby_vok/issues).
+
+## Лицензия
+
+MIT - см. `LICENSE.txt`.
+
+## Автор
+
+Vitalii Dementev - [@DementevVV](https://github.com/DementevVV)

data/lib/saby_vok/auth.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "mutex_m"
+require "httparty"
+
+module SabyVok
+  class Auth
+    include Mutex_m
+
+    JSON_HEADERS = { "Content-Type" => "application/json; charset=utf-8" }.freeze
+
+    # @param credentials [Hash, #to_h] keys :client_id, :client_secret, :secret_key
+    # @param oauth_url [String] OAuth endpoint URL
+    # @param timeout [Integer] request timeout in seconds
+    # @param logger [Logger, nil]
+    def initialize(credentials:, oauth_url:, timeout:, logger: nil)
+      super() # Mutex_m init
+      creds = normalize_credentials(credentials)
+      @client_id = creds.fetch(:client_id)
+      @client_secret = creds.fetch(:client_secret)
+      @secret_key = creds.fetch(:secret_key)
+      @oauth_uri = URI(oauth_url)
+      @timeout = timeout
+      @logger = logger
+      @tokens = nil
+    end
+
+    # @return [Hash{Symbol=>String}] :access_token and :session_id
+    def tokens
+      synchronize do
+        @tokens ||= obtain_tokens
+      end
+    end
+
+    # @return [Hash{Symbol=>String}] refreshed tokens
+    def refresh!
+      synchronize do
+        @tokens = obtain_tokens
+      end
+    end
+
+    # @return [void]
+    def invalidate!
+      synchronize do
+        @tokens = nil
+      end
+    end
+
+    private
+
+    def obtain_tokens
+      response = perform_oauth_request
+      ensure_success!(response)
+      parse_token_payload(response)
+    end
+
+    def log(message)
+      return unless @logger
+
+      @logger.info("[saby_vok] #{message}")
+    end
+
+    def perform_oauth_request
+      log("Auth: POST #{@oauth_uri}")
+      HTTParty.post(@oauth_uri, oauth_request_options)
+    end
+
+    def ensure_success!(response)
+      code = response.code.to_i
+      body = response.body
+      return if code.between?(200, 299)
+
+      raise AuthError.new("Auth failed HTTP #{code}", status: code, body: body)
+    end
+
+    def parse_token_payload(response)
+      extract_token_fields(JSON.parse(response.body))
+    rescue JSON::ParserError, KeyError => e
+      raise AuthError.new(
+        "Auth response parsing failed: #{e.message}",
+        status: response.code.to_i,
+        body: response.body
+      )
+    end
+
+    def oauth_request_options
+      {
+        headers: JSON_HEADERS,
+        body: oauth_request_body,
+        timeout: @timeout
+      }
+    end
+
+    def oauth_request_body
+      credentials_payload.to_json
+    end
+
+    def credentials_payload
+      {
+        app_client_id: @client_id,
+        app_secret: @client_secret,
+        secret_key: @secret_key
+      }
+    end
+
+    def extract_token_fields(parsed)
+      {
+        access_token: parsed.fetch("access_token"),
+        session_id: parsed.fetch("sid")
+      }
+    end
+
+    def normalize_credentials(credentials)
+      creds_hash = credentials.respond_to?(:to_h) ? credentials.to_h : credentials
+      raise ArgumentError, "credentials must be a Hash-like object" unless creds_hash.is_a?(Hash)
+
+      creds_hash.transform_keys(&:to_sym)
+    end
+  end
+end

data/lib/saby_vok/client.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "errors"
+require_relative "http"
+require_relative "auth"
+require_relative "version"
+
+module SabyVok
+  class Client
+    DEFAULT_HOST = "https://api.sbis.ru/vok/"
+    DEFAULT_OAUTH_URL = "https://api.sbis.ru/oauth/service/"
+    DEFAULT_CONFIG = {
+      host: DEFAULT_HOST,
+      oauth_url: DEFAULT_OAUTH_URL,
+      timeout: Http::DEFAULT_TIMEOUT,
+      retries: Http::DEFAULT_RETRIES,
+      logger: nil
+    }.freeze
+
+    # Thin, happy-path client for the VOK API.
+    #
+    # @example Direct initialization and fetching requisites
+    #   client = SabyVok::Client.new("id", "secret", "key")
+    #   data = client.req(inn: "7605016030")
+    #   puts data.first["company_name"]
+    #
+    # @example Getting a logo as binary
+    #   logo_bytes = client.logo(inn: "7605016030")
+    #   File.binwrite("logo.png", logo_bytes)
+    #
+    # @overload initialize(client_id, client_secret, secret_key, **options)
+    #   @param client_id [String]
+    #   @param client_secret [String]
+    #   @param secret_key [String]
+    #   @param options [Hash] optional config (see below)
+    # @overload initialize(credentials:, **options)
+    #   @param credentials [Hash] keys :client_id, :client_secret, :secret_key
+    #   @param options [Hash]
+    # @option options [String] :host (DEFAULT_HOST)
+    # @option options [String] :oauth_url (DEFAULT_OAUTH_URL)
+    # @option options [Integer] :timeout (Http::DEFAULT_TIMEOUT)
+    # @option options [Integer] :retries (Http::DEFAULT_RETRIES)
+    # @option options [Logger,nil] :logger
+    def initialize(*credential_args, credentials: nil, **options)
+      creds = resolve_credentials(credential_args, credentials)
+      config = build_config(options)
+
+      @host = URI(config[:host])
+      @oauth_url = config[:oauth_url]
+      @logger = config[:logger]
+      timeout = config[:timeout]
+      retries = config[:retries]
+
+      @http = Http.new(logger: @logger, timeout: timeout, retries: retries)
+      @auth = Auth.new(
+        credentials: creds,
+        oauth_url: @oauth_url,
+        timeout: timeout,
+        logger: @logger
+      )
+    end
+
+    # Requisites
+    # @return [Array<Hash>, Hash]
+    def req(inn: nil, ogrn: nil, kpp: nil)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      ensure_kpp_valid!(inn, kpp)
+      request_json("req", params: { inn: inn, ogrn: ogrn, kpp: kpp })
+    end
+
+    # @return [String] binary logo data
+    def logo(inn: nil, ogrn: nil, kpp: nil)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      ensure_kpp_valid!(inn, kpp)
+      request_binary("logo", params: { inn: inn, ogrn: ogrn, kpp: kpp })
+    end
+
+    # @return [Array<Hash>, Hash]
+    def registration_information(inn: nil, ogrn: nil, kpp: nil)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      ensure_kpp_valid!(inn, kpp)
+      request_json("registration-information", params: { inn: inn, ogrn: ogrn, kpp: kpp })
+    end
+
+    # Tenders
+    # @return [Array<Hash>, Hash]
+    def tenders_info(inn: nil, ogrn: nil)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      request_json("tenders-info", params: { inn: inn, ogrn: ogrn })
+    end
+
+    # @param limit [Integer]
+    # @param page [Integer]
+    # @return [Array<Hash>, Hash]
+    def tenders(inn: nil, ogrn: nil, limit: 10, page: 0)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      ensure_pagination!(limit, page)
+      request_json("tenders", params: { inn: inn, ogrn: ogrn, limit: limit, page: page })
+    end
+
+    # Analytics
+    def finance(inn: nil, ogrn: nil) = ensure_and_get_json("finance", inn, ogrn)
+    def cost_business(inn: nil, ogrn: nil) = ensure_and_get_json("cost-business", inn, ogrn)
+    def reliability(inn: nil, ogrn: nil) = ensure_and_get_json("reliability", inn, ogrn)
+    def reliability_blocks(inn: nil, ogrn: nil) = ensure_and_get_json("reliability/blocks", inn, ogrn)
+    def market_position(inn: nil, ogrn: nil) = ensure_and_get_json("market-position", inn, ogrn)
+    def creditworthiness(inn: nil, ogrn: nil) = ensure_and_get_json("creditworthiness", inn, ogrn)
+
+    # Person / relations
+    def owners(inn: nil, ogrn: nil) = ensure_and_get_json("owners", inn, ogrn)
+    def affiliate(inn: nil, ogrn: nil) = ensure_and_get_json("affiliate", inn, ogrn)
+    def dirs_history(inn: nil, ogrn: nil) = ensure_and_get_json("dirs-history", inn, ogrn)
+    def founders_history(inn: nil, ogrn: nil) = ensure_and_get_json("founders-history", inn, ogrn)
+
+    # Licenses / inspections
+    def license_stat(inn: nil, ogrn: nil) = ensure_and_get_json("license/stat", inn, ogrn)
+    def license_data(inn: nil, ogrn: nil) = ensure_and_get_json("license/data", inn, ogrn)
+    def inspections_stat(inn: nil, ogrn: nil) = ensure_and_get_json("inspections/stat", inn, ogrn)
+    def inspections_data(inn: nil, ogrn: nil) = ensure_and_get_json("inspections/data", inn, ogrn)
+
+    # SRO
+    def sro(inn: nil, ogrn: nil) = ensure_and_get_json("sro", inn, ogrn)
+    def sro_file(inn: nil, ogrn: nil) = ensure_and_get_binary("sro/file", inn, ogrn)
+
+    # Courts / bankruptcy
+    def statistic_courts(inn: nil, ogrn: nil) = ensure_and_get_json("statistic-courts", inn, ogrn)
+    def courts(inn: nil, ogrn: nil) = ensure_and_get_json("courts", inn, ogrn)
+    def executive_lists(inn: nil, ogrn: nil) = ensure_and_get_json("executive-lists", inn, ogrn)
+    def bankruptcy(inn: nil, ogrn: nil) = ensure_and_get_json("bankruptcy", inn, ogrn)
+    def bankruptcy_file(inn: nil, ogrn: nil) = ensure_and_get_binary("bankruptcy/file", inn, ogrn)
+
+    # External economic activity
+    def fea(inn: nil, ogrn: nil) = ensure_and_get_json("fea", inn, ogrn)
+
+    # Events / subscriptions
+    # @return [Array<Hash>, Hash]
+    def events(inn: nil, ogrn: nil) = ensure_and_get_json("events", inn, ogrn)
+    # @return [String] binary file data
+    def events_file(inn: nil, ogrn: nil) = ensure_and_get_binary("events/file", inn, ogrn)
+    # @return [Array<Hash>, Hash]
+    def subscriptions_events(inn: nil, ogrn: nil) = ensure_and_get_json("subscriptions/events", inn, ogrn)
+    # @return [Array<Hash>, Hash]
+    def subscriptions_contractors(inn: nil, ogrn: nil) = ensure_and_get_json("subscriptions/contractors", inn, ogrn)
+
+    # @return [Array<Hash>, Hash]
+    def subscribe(inn: nil, ogrn: nil, **params)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      request_json("subscriptions/subscribe", params: { inn: inn, ogrn: ogrn }.merge(params), method: :post)
+    end
+
+    # @return [Array<Hash>, Hash]
+    def unsubscribe(inn: nil, ogrn: nil, **params)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      request_json("subscriptions/unsubscribe", params: { inn: inn, ogrn: ogrn }.merge(params), method: :post)
+    end
+
+    # History / contacts / branches
+    def contractor_history(inn: nil, ogrn: nil) = ensure_and_get_json("contractor-history", inn, ogrn)
+    def contacts_official(inn: nil, ogrn: nil) = ensure_and_get_json("contacts-official", inn, ogrn)
+    def branches(inn: nil, ogrn: nil) = ensure_and_get_json("branches", inn, ogrn)
+
+    # Excerpts
+    # @return [Array<Hash>, Hash]
+    def excerpts_list(inn: nil, ogrn: nil) = ensure_and_get_json("excerpts/list", inn, ogrn)
+    # @return [Array<Hash>, Hash]
+    def excerpts_last(inn: nil, ogrn: nil) = ensure_and_get_json("excerpts/last", inn, ogrn)
+    # @return [String] binary file data
+    def excerpts_file(inn: nil, ogrn: nil) = ensure_and_get_binary("excerpts/file", inn, ogrn)
+
+    # Search / stats
+    # @return [Array<Hash>, Hash]
+    def search(query:, **params)
+      raise ValidationError, "query is required" if query.nil? || query.to_s.strip.empty?
+
+      request_json("search", params: { query: query }.merge(params))
+    end
+
+    # @return [Array<Hash>, Hash]
+    def client_stat(**params)
+      request_json("client/stat", params: params)
+    end
+
+    # Trademarks / vehicles / pledges
+    # @return [Array<Hash>, Hash]
+    def trademarks(inn: nil, ogrn: nil) = ensure_and_get_json("trademarks", inn, ogrn)
+    # @return [String] binary image data
+    def trademarks_image(inn: nil, ogrn: nil) = ensure_and_get_binary("trademarks/image", inn, ogrn)
+    # @return [Array<Hash>, Hash]
+    def vehicle(inn: nil, ogrn: nil) = ensure_and_get_json("vehicle", inn, ogrn)
+    # @return [Array<Hash>, Hash]
+    def vehicle_stat(inn: nil, ogrn: nil) = ensure_and_get_json("vehicle/stat", inn, ogrn)
+    # @return [Array<Hash>, Hash]
+    def pledges(inn: nil, ogrn: nil) = ensure_and_get_json("pledges", inn, ogrn)
+    # @return [String] binary file data
+    def pledges_file(inn: nil, ogrn: nil) = ensure_and_get_binary("pledges/file", inn, ogrn)
+
+    # Reports
+    # @return [String] PDF binary
+    def pdf_business_report(inn: nil, ogrn: nil) = ensure_and_get_binary("pdf/business-report", inn, ogrn)
+    # @return [String] PDF binary
+    def pdf_due_diligence_report(inn: nil, ogrn: nil) = ensure_and_get_binary("pdf/due-diligence-report", inn, ogrn)
+    # @return [String] PDF binary
+    def pdf_financial_report(inn: nil, ogrn: nil) = ensure_and_get_binary("pdf/financial-report", inn, ogrn)
+    # @return [String] PDF binary
+    def pdf_signed_excerpt(inn: nil, ogrn: nil) = ensure_and_get_binary("pdf/signed-excerpt", inn, ogrn)
+    # @return [String] XML binary
+    def xml_egrul_excerpt(inn: nil, ogrn: nil) = ensure_and_get_binary("xml/egrul-excerpt", inn, ogrn)
+    # @return [String] XML binary
+    def xml_reporting_excerpt(inn: nil, ogrn: nil) = ensure_and_get_binary("xml/reporting-excerpt", inn, ogrn)
+
+    private
+
+    # @return [Array<Hash>, Hash]
+    def ensure_and_get_json(path, inn, ogrn)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      request_json(path, params: { inn: inn, ogrn: ogrn })
+    end
+
+    # @return [String]
+    def ensure_and_get_binary(path, inn, ogrn)
+      ensure_inn_or_ogrn!(inn, ogrn)
+      request_binary(path, params: { inn: inn, ogrn: ogrn })
+    end
+
+    def build_uri(path)
+      URI.join(@host.to_s.end_with?("/") ? @host.to_s : "#{@host}/", path)
+    end
+
+    def request_json(path, params:, method: :get)
+      perform_request(path, params: params, method: method, expect_binary: false)
+    end
+
+    def request_binary(path, params:, method: :get)
+      perform_request(path, params: params, method: method, expect_binary: true)
+    end
+
+    def perform_request(path, params:, method:, expect_binary:)
+      attempts = 0
+      begin
+        attempts += 1
+        tokens = @auth.tokens
+        headers = default_headers(tokens)
+        @http.request(
+          method: method,
+          uri: build_uri(path),
+          headers: headers,
+          params: compact_params(params),
+          expect_binary: expect_binary
+        )
+      rescue HttpError => e
+        if [ 401, 403 ].include?(e.status.to_i) && attempts < 2
+          @auth.refresh!
+          retry
+        end
+        raise
+      end
+    end
+
+    def resolve_credentials(credential_args, credentials)
+      return normalize_credentials(credentials) if credentials
+
+      unless credential_args.size == 3
+        raise ArgumentError, "provide client_id, client_secret, secret_key or pass credentials: { ... }"
+      end
+
+      {
+        client_id: credential_args[0],
+        client_secret: credential_args[1],
+        secret_key: credential_args[2]
+      }
+    end
+
+    def build_config(options)
+      symbolized = symbolize_keys(options)
+      unknown = symbolized.keys - DEFAULT_CONFIG.keys
+      raise ArgumentError, "unknown option(s): #{unknown.join(', ')}" if unknown.any?
+
+      DEFAULT_CONFIG.merge(symbolized)
+    end
+
+    def normalize_credentials(values)
+      return symbolize_keys(values.to_h) if values.respond_to?(:to_h)
+
+      raise ArgumentError, "credentials must respond to #to_h"
+    end
+
+    def symbolize_keys(hash)
+      hash.transform_keys(&:to_sym)
+    end
+
+    def ensure_inn_or_ogrn!(inn, ogrn)
+      return if (inn && !inn.to_s.empty?) || (ogrn && !ogrn.to_s.empty?)
+
+      raise ValidationError, "either inn or ogrn is required"
+    end
+
+    def ensure_kpp_valid!(inn, kpp)
+      return unless kpp
+
+      raise ValidationError, "kpp requires inn" unless inn
+    end
+
+    def ensure_pagination!(limit, page)
+      raise ValidationError, "limit must be positive" unless limit.to_i.positive?
+      raise ValidationError, "page must be non-negative" if page.to_i.negative?
+    end
+
+    def compact_params(params)
+      params.each_with_object({}) do |(k, v), acc|
+        acc[k] = v unless v.nil?
+      end
+    end
+
+    def default_headers(tokens)
+      {
+        "User-Agent" => "SabyVok Ruby Client / #{VERSION}",
+        "X-SBISAccessToken" => tokens[:access_token],
+        "X-SBISSessionId" => tokens[:session_id],
+        "Content-Type" => "application/json; charset=utf-8"
+      }
+    end
+  end
+end

data/lib/saby_vok/errors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SabyVok
+  class Error < StandardError; end
+
+  class ValidationError < Error; end
+
+  class AuthError < Error
+    attr_reader :status, :body
+
+    def initialize(message, status:, body: nil)
+      super(message)
+      @status = status
+      @body = body
+    end
+  end
+
+  class HttpError < Error
+    attr_reader :status, :body
+
+    def initialize(message, status:, body:)
+      super(message)
+      @status = status
+      @body = body
+    end
+  end
+
+  class ParsingError < Error
+    attr_reader :body
+
+    def initialize(message, body:)
+      super(message)
+      @body = body
+    end
+  end
+end

data/lib/saby_vok/http.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "json"
+require "timeout"
+
+module SabyVok
+  class Http
+    DEFAULT_TIMEOUT = 15
+    DEFAULT_RETRIES = 2
+    RETRYABLE_CODES = [ 429, 502, 503, 504 ].freeze
+
+    # @param logger [Logger, nil]
+    # @param timeout [Integer]
+    # @param retries [Integer]
+    def initialize(logger: nil, timeout: DEFAULT_TIMEOUT, retries: DEFAULT_RETRIES)
+      @logger = logger
+      @timeout = timeout
+      @retries = retries
+    end
+
+    # @param method [Symbol, String] :get or :post
+    # @param uri [URI::HTTP]
+    # @param headers [Hash]
+    # @param params [Hash]
+    # @param expect_binary [Boolean]
+    # @return [Hash, Array, String]
+    # @raise [HttpError, ParsingError]
+    def request(method:, uri:, headers:, params:, expect_binary: false)
+      raise ArgumentError, "uri must be URI" unless uri.is_a?(URI)
+
+      attempts = 0
+      loop do
+        attempts += 1
+        response = perform_request(method, uri, headers, params)
+        if retryable_response?(response) && attempts <= @retries + 1
+          backoff(attempts)
+          next
+        end
+        return parse_response(response, expect_binary: expect_binary)
+      rescue Timeout::Error => e
+        if attempts <= @retries + 1
+          backoff(attempts)
+          next
+        end
+        raise HttpError.new("request timed out: #{e.class}", status: 504, body: nil)
+      rescue SocketError, Errno::ECONNREFUSED => e
+        raise HttpError.new(
+          "connection failed: #{e.class} #{e.message}",
+          status: 503,
+          body: nil
+        )
+      end
+    end
+
+    private
+
+    def perform_request(method, uri, headers, params)
+      options = {
+        headers: headers,
+        timeout: @timeout
+      }
+
+      if method.to_s.downcase.to_sym == :post
+        options[:headers] = headers.merge("Content-Type" => "application/json; charset=utf-8")
+        options[:body] = params.to_json
+      else
+        options[:query] = params.compact
+      end
+
+      HTTParty.send(method, uri, options)
+    end
+
+    def retryable_response?(response)
+      RETRYABLE_CODES.include?(response.code.to_i)
+    end
+
+    def backoff(attempts)
+      delay = 0.5 * (2**(attempts - 1))
+      log("retrying in #{delay.round(2)}s (attempt #{attempts})")
+      sleep(delay)
+    end
+
+    def parse_response(response, expect_binary:)
+      code = response.code.to_i
+      body = response.body
+      return body if expect_binary && code.between?(200, 299)
+
+      return response.parsed_response if code.between?(200, 299)
+
+      raise HttpError.new("HTTP #{code}", status: code, body: body)
+    rescue JSON::ParserError => e
+      raise ParsingError.new("failed to parse JSON: #{e.message}", body: response.body)
+    end
+
+    def log(message)
+      return unless @logger
+
+      @logger.info("[saby_vok] #{message}")
+    end
+  end
+end

data/lib/saby_vok/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SabyVok
+  VERSION = "0.1.0"
+end

data/lib/saby_vok.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "thread"
+require_relative "saby_vok/version"
+require_relative "saby_vok/errors"
+require_relative "saby_vok/http"
+require_relative "saby_vok/auth"
+require_relative "saby_vok/client"
+
+module SabyVok
+  # @example Configure once and reuse the client
+  #   SabyVok.configure do |config|
+  #     config.client_id = ENV.fetch("SABY_CLIENT_ID")
+  #     config.client_secret = ENV.fetch("SABY_CLIENT_SECRET")
+  #     config.secret_key = ENV.fetch("SABY_SECRET_KEY")
+  #   end
+  #
+  #   requisites = SabyVok.client.req(inn: "7605016030")
+  #   puts requisites.first["company_name"]
+  class Config
+    attr_accessor :client_id, :client_secret, :secret_key, :host, :oauth_url, :timeout, :retries, :logger
+  end
+
+  class << self
+    attr_writer :client
+
+    # @return [SabyVok::Client, nil]
+    def client
+      mutex.synchronize do
+        @client ||= build_client_from_config
+      end
+    end
+
+    # @yield [Config]
+    # @return [void]
+    def configure
+      mutex.synchronize do
+        yield(config)
+      end
+    end
+
+    # Drops the memoized client so the next call to {#client} rebuilds it with updated config.
+    #
+    # @return [void]
+    def reset_client!
+      mutex.synchronize do
+        @client = nil
+      end
+    end
+
+    # @return [Config]
+    def config
+      @config ||= Config.new
+    end
+
+    private
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+    def build_client_from_config
+      return nil unless config.client_id && config.client_secret && config.secret_key
+
+      Client.new(
+        config.client_id,
+        config.client_secret,
+        config.secret_key,
+        host: config.host,
+        oauth_url: config.oauth_url,
+        timeout: config.timeout,
+        retries: config.retries,
+        logger: config.logger
+      )
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: saby_vok
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vitalii Dementev
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Thin Ruby wrapper around the Saby Vok API with easy auth and binary/JSON
+  helpers.
+email:
+- v@dementev.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/saby_vok.rb
+- lib/saby_vok/auth.rb
+- lib/saby_vok/client.rb
+- lib/saby_vok/errors.rb
+- lib/saby_vok/http.rb
+- lib/saby_vok/version.rb
+homepage: https://dementevvv.github.io/saby_vok/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://dementevvv.github.io/saby_vok/
+  documentation_uri: https://dementevvv.github.io/saby_vok/
+  source_code_uri: https://github.com/DementevVV/saby_vok
+  changelog_uri: https://github.com/DementevVV/saby_vok/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/DementevVV/saby_vok/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Ruby client for Saby Vok API
+test_files: []