weft-sdk 0.25.0 → 0.32.2

data/docs/WebhooksApi.md

@@ -0,0 +1,414 @@
+# Weft::WebhooksApi
+
+All URIs are relative to *https://weft.network*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**create_webhook_endpoint**](WebhooksApi.md#create_webhook_endpoint) | **POST** /api/v1/webhook_endpoints | Create a webhook endpoint |
+| [**delete_webhook_endpoint**](WebhooksApi.md#delete_webhook_endpoint) | **DELETE** /api/v1/webhook_endpoints/{id} | Delete a webhook endpoint |
+| [**get_webhook_endpoint**](WebhooksApi.md#get_webhook_endpoint) | **GET** /api/v1/webhook_endpoints/{id} | Get a webhook endpoint |
+| [**list_webhook_endpoints**](WebhooksApi.md#list_webhook_endpoints) | **GET** /api/v1/webhook_endpoints | List webhook endpoints |
+| [**replace_webhook_endpoint**](WebhooksApi.md#replace_webhook_endpoint) | **PUT** /api/v1/webhook_endpoints/{id} | Replace a webhook endpoint |
+| [**update_webhook_endpoint**](WebhooksApi.md#update_webhook_endpoint) | **PATCH** /api/v1/webhook_endpoints/{id} | Update a webhook endpoint |
+
+
+## create_webhook_endpoint
+
+> create_webhook_endpoint
+
+Create a webhook endpoint
+
+Retired. Returns HTTP 410 with error code `gone`. The body is ignored.
+
+### Examples
+
+```ruby
+require 'time'
+require 'weft-sdk'
+# setup authorization
+Weft.configure do |config|
+  # Configure Bearer authorization (APIKey): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Weft::WebhooksApi.new
+
+begin
+  # Create a webhook endpoint
+  api_instance.create_webhook_endpoint
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->create_webhook_endpoint: #{e}"
+end
+```
+
+#### Using the create_webhook_endpoint_with_http_info variant
+
+This returns an Array which contains the response data (`nil` in this case), status code and headers.
+
+> <Array(nil, Integer, Hash)> create_webhook_endpoint_with_http_info
+
+```ruby
+begin
+  # Create a webhook endpoint
+  data, status_code, headers = api_instance.create_webhook_endpoint_with_http_info
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => nil
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->create_webhook_endpoint_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## delete_webhook_endpoint
+
+> delete_webhook_endpoint(id)
+
+Delete a webhook endpoint
+
+Retired. Returns HTTP 410 with error code `gone`. Stored rows are kept.
+
+### Examples
+
+```ruby
+require 'time'
+require 'weft-sdk'
+# setup authorization
+Weft.configure do |config|
+  # Configure Bearer authorization (APIKey): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Weft::WebhooksApi.new
+id = 56 # Integer | Webhook endpoint ID. Ignored. The response is always HTTP 410.
+
+begin
+  # Delete a webhook endpoint
+  api_instance.delete_webhook_endpoint(id)
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->delete_webhook_endpoint: #{e}"
+end
+```
+
+#### Using the delete_webhook_endpoint_with_http_info variant
+
+This returns an Array which contains the response data (`nil` in this case), status code and headers.
+
+> <Array(nil, Integer, Hash)> delete_webhook_endpoint_with_http_info(id)
+
+```ruby
+begin
+  # Delete a webhook endpoint
+  data, status_code, headers = api_instance.delete_webhook_endpoint_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => nil
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->delete_webhook_endpoint_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **Integer** | Webhook endpoint ID. Ignored. The response is always HTTP 410. |  |
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_webhook_endpoint
+
+> get_webhook_endpoint(id)
+
+Get a webhook endpoint
+
+Retired. Returns HTTP 410 with error code `gone`.
+
+### Examples
+
+```ruby
+require 'time'
+require 'weft-sdk'
+# setup authorization
+Weft.configure do |config|
+  # Configure Bearer authorization (APIKey): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Weft::WebhooksApi.new
+id = 56 # Integer | Webhook endpoint ID. Ignored. The response is always HTTP 410.
+
+begin
+  # Get a webhook endpoint
+  api_instance.get_webhook_endpoint(id)
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->get_webhook_endpoint: #{e}"
+end
+```
+
+#### Using the get_webhook_endpoint_with_http_info variant
+
+This returns an Array which contains the response data (`nil` in this case), status code and headers.
+
+> <Array(nil, Integer, Hash)> get_webhook_endpoint_with_http_info(id)
+
+```ruby
+begin
+  # Get a webhook endpoint
+  data, status_code, headers = api_instance.get_webhook_endpoint_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => nil
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->get_webhook_endpoint_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **Integer** | Webhook endpoint ID. Ignored. The response is always HTTP 410. |  |
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## list_webhook_endpoints
+
+> list_webhook_endpoints
+
+List webhook endpoints
+
+Retired. Returns HTTP 410 with error code `gone`.
+
+### Examples
+
+```ruby
+require 'time'
+require 'weft-sdk'
+# setup authorization
+Weft.configure do |config|
+  # Configure Bearer authorization (APIKey): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Weft::WebhooksApi.new
+
+begin
+  # List webhook endpoints
+  api_instance.list_webhook_endpoints
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->list_webhook_endpoints: #{e}"
+end
+```
+
+#### Using the list_webhook_endpoints_with_http_info variant
+
+This returns an Array which contains the response data (`nil` in this case), status code and headers.
+
+> <Array(nil, Integer, Hash)> list_webhook_endpoints_with_http_info
+
+```ruby
+begin
+  # List webhook endpoints
+  data, status_code, headers = api_instance.list_webhook_endpoints_with_http_info
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => nil
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->list_webhook_endpoints_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## replace_webhook_endpoint
+
+> replace_webhook_endpoint(id)
+
+Replace a webhook endpoint
+
+Retired. Returns HTTP 410 with error code `gone`. The body is ignored.
+
+### Examples
+
+```ruby
+require 'time'
+require 'weft-sdk'
+# setup authorization
+Weft.configure do |config|
+  # Configure Bearer authorization (APIKey): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Weft::WebhooksApi.new
+id = 56 # Integer | Webhook endpoint ID. Ignored. The response is always HTTP 410.
+
+begin
+  # Replace a webhook endpoint
+  api_instance.replace_webhook_endpoint(id)
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->replace_webhook_endpoint: #{e}"
+end
+```
+
+#### Using the replace_webhook_endpoint_with_http_info variant
+
+This returns an Array which contains the response data (`nil` in this case), status code and headers.
+
+> <Array(nil, Integer, Hash)> replace_webhook_endpoint_with_http_info(id)
+
+```ruby
+begin
+  # Replace a webhook endpoint
+  data, status_code, headers = api_instance.replace_webhook_endpoint_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => nil
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->replace_webhook_endpoint_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **Integer** | Webhook endpoint ID. Ignored. The response is always HTTP 410. |  |
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## update_webhook_endpoint
+
+> update_webhook_endpoint(id)
+
+Update a webhook endpoint
+
+Retired. Returns HTTP 410 with error code `gone`. The body is ignored.
+
+### Examples
+
+```ruby
+require 'time'
+require 'weft-sdk'
+# setup authorization
+Weft.configure do |config|
+  # Configure Bearer authorization (APIKey): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Weft::WebhooksApi.new
+id = 56 # Integer | Webhook endpoint ID. Ignored. The response is always HTTP 410.
+
+begin
+  # Update a webhook endpoint
+  api_instance.update_webhook_endpoint(id)
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->update_webhook_endpoint: #{e}"
+end
+```
+
+#### Using the update_webhook_endpoint_with_http_info variant
+
+This returns an Array which contains the response data (`nil` in this case), status code and headers.
+
+> <Array(nil, Integer, Hash)> update_webhook_endpoint_with_http_info(id)
+
+```ruby
+begin
+  # Update a webhook endpoint
+  data, status_code, headers = api_instance.update_webhook_endpoint_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => nil
+rescue Weft::ApiError => e
+  puts "Error when calling WebhooksApi->update_webhook_endpoint_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **Integer** | Webhook endpoint ID. Ignored. The response is always HTTP 410. |  |
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json

data/lib/weft/client.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'error'
+require_relative 'generated'
+
+module Weft
+  # Buyer façade over the generated API client.
+  class Client
+    def initialize(api_key: nil, access_token: nil, base_url: 'https://weft.network')
+      if !api_key.nil? && !access_token.nil?
+        raise ArgumentError, 'api_key and access_token are mutually exclusive'
+      end
+
+      raw = api_key.nil? ? access_token : api_key
+      credential = raw.is_a?(String) ? raw.strip : ''
+      if credential.empty?
+        raise ArgumentError, credential_error(api_key, access_token)
+      end
+
+      configuration = Configuration.new
+      apply_base_url(configuration, base_url)
+      configuration.access_token = credential
+      @api_client = ApiClient.new(configuration)
+      @account = AccountApi.new(@api_client)
+      @balance = BalanceApi.new(@api_client)
+      @search = SearchApi.new(@api_client)
+      @fetch = FetchApi.new(@api_client)
+      @purchases = PurchasesApi.new(@api_client)
+    end
+
+    def me
+      call { @account.get_me }
+    end
+
+    def balance
+      call { @balance.get_balance }
+    end
+
+    def search(query:, max_results: nil, filters: nil)
+      request = SearchRequest.new(query: query)
+      if max_results.nil?
+        request.remove_instance_variable(:@max_results)
+      else
+        request.max_results = max_results
+      end
+      request.filters = search_filters(filters) unless filters.nil?
+      call { @search.search(request) }
+    end
+
+    def fetch(url:, max_cost_usd:, idempotency_key:, method: nil, body: nil, headers: nil,
+              search_id: nil, operation_id: nil, access_method_id: nil)
+      raise ArgumentError, 'max_cost_usd is required' if max_cost_usd.to_s.strip.empty?
+      raise ArgumentError, 'idempotency_key is required' if idempotency_key.to_s.strip.empty?
+      # Weft's limit. Checked here so a bad key never looks like a paid failure.
+      unless idempotency_key.to_s.match?(/\A[!-~]{1,255}\z/)
+        raise ArgumentError, 'idempotency_key must be 1-255 visible ASCII characters without spaces'
+      end
+
+      fields = {
+        url: url,
+        max_cost_usd: max_cost_usd,
+        method: method.nil? ? nil : method.to_s.upcase
+      }
+      fields[:body] = fetch_body(body) unless body.nil?
+      fields[:headers] = headers.transform_keys(&:to_s) unless headers.nil?
+      fields[:search_id] = search_id unless search_id.nil?
+      fields[:operation_id] = operation_id unless operation_id.nil?
+      fields[:access_method_id] = access_method_id unless access_method_id.nil?
+      request = FetchRequest.new(fields)
+      response = call(paid: true) { @fetch.fetch(request, idempotency_key: idempotency_key) }
+      # A 2xx without a fetch result body: the fetch most likely paid.
+      raise decode_error if response.nil?
+
+      response
+    end
+
+    def purchases(page: nil, per_page: nil)
+      call { @purchases.list_purchases(page: page, per_page: per_page) }
+    end
+
+    def purchase(id)
+      call { @purchases.get_purchase(id) }
+    end
+
+    private
+
+    def call(paid: false)
+      yield
+    rescue ApiError => e
+      raise normalize_api_error(e, paid: paid)
+    rescue StandardError => e
+      raise if !paid || e.is_a?(RequestError)
+
+      # Weft answered 2xx, so the fetch most likely paid, but the body did not decode.
+      raise decode_error
+    end
+
+    # A replay returns the same body; reconcile instead of retrying.
+    def decode_error
+      RequestError.new(
+        status: 0,
+        code: 'RESPONSE_DECODE_ERROR',
+        message: 'Weft API returned a fetch response that could not be decoded',
+        retryable: false,
+        charge: 'possible'
+      )
+    end
+
+    def credential_error(api_key, access_token)
+      return 'api_key is required' unless api_key.nil?
+      return 'access_token is required' unless access_token.nil?
+
+      'api_key or access_token is required'
+    end
+
+    def apply_base_url(configuration, base_url)
+      stripped = trim_trailing_slashes(base_url.to_s)
+      uri = URI.parse(stripped)
+      configuration.scheme = uri.scheme || 'https'
+      configuration.host = uri.host || trim_trailing_slashes(stripped)
+      path = collapse_slashes(uri.path.to_s)
+      path = trim_trailing_slashes(path)
+      path = strip_leading_slashes(path)
+      configuration.base_path = path
+    end
+
+    def trim_trailing_slashes(value)
+      text = value.dup
+      text.chomp!('/') while text.end_with?('/')
+      text
+    end
+
+    def strip_leading_slashes(value)
+      index = 0
+      index += 1 while index < value.length && value[index] == '/'
+      index.zero? ? value : value[index..]
+    end
+
+    def collapse_slashes(value)
+      out = +''
+      previous_slash = false
+      value.each_char do |char|
+        if char == '/'
+          out << '/' unless previous_slash
+          previous_slash = true
+        else
+          out << char
+          previous_slash = false
+        end
+      end
+      out
+    end
+
+    def search_filters(value)
+      mapped = map_filters(value)
+      spec = SearchFilterSpec.new(mapped)
+      spec.include_unknown_prices = nil unless mapped.key?(:include_unknown_prices)
+      spec
+    end
+
+    def map_filters(value)
+      table = {
+        'price' => :price,
+        'priceAtomic' => :price_atomic,
+        'type' => :type,
+        'protocol' => :protocol,
+        'category' => :category,
+        'method' => :method,
+        'executionMode' => :execution_mode,
+        'weftFetchCompatible' => :weft_fetch_compatible,
+        'includeUnknownPrices' => :include_unknown_prices
+      }
+      nested = %i[price price_atomic type protocol category method execution_mode]
+      operators = {
+        'lte' => :lte,
+        'gte' => :gte,
+        'eq' => :eq,
+        'in' => :in,
+        'rangeGte' => :range_gte,
+        'rangeLte' => :range_lte
+      }
+      mapped = map_keys(value, table)
+      nested.each do |name|
+        child = mapped[name]
+        next unless child.is_a?(Hash)
+
+        mapped[name] = map_keys(child, operators)
+      end
+      mapped
+    end
+
+    def map_keys(source, table)
+      source.each_with_object({}) do |(key, item), out|
+        mapped = table[key.to_s] || table[key.to_sym]
+        raise ArgumentError, "unmapped field #{key}" if mapped.nil?
+
+        out[mapped] = item
+      end
+    end
+
+    def fetch_body(value)
+      return value if value.is_a?(String)
+
+      JSON.generate(json_null_non_finite(value))
+    end
+
+    def json_null_non_finite(value)
+      case value
+      when Float
+        value.finite? ? value : nil
+      when Hash
+        value.each_with_object({}) { |(key, item), out| out[key] = json_null_non_finite(item) }
+      when Array
+        value.map { |item| json_null_non_finite(item) }
+      else
+        value
+      end
+    end
+
+    def normalize_api_error(error, paid:)
+      if error.code.to_i.zero? && !error.response_body
+        cause = error.instance_variable_get(:@message).to_s
+        cause = 'connection reset' if cause.empty?
+        return RequestError.new(
+          status: 0,
+          code: 'NETWORK_ERROR',
+          message: "Network failure before a Weft API response: #{cause}",
+          request_id: nil,
+          retryable: true,
+          details: nil,
+          charge: paid ? 'possible' : 'none'
+        )
+      end
+
+      details = parse_details(error.response_body)
+      body = details.is_a?(Hash) ? details : nil
+      nested = body && body['error'].is_a?(Hash) ? body['error'] : nil
+      status = error.code.to_i
+      code = nested&.[]('code') || body&.[]('code') || (body && body['error'].is_a?(String) ? body['error'] : "HTTP_#{status}")
+      RequestError.new(
+        status: status,
+        code: code,
+        message: nested&.[]('message') || body&.[]('message') || "Weft API returned HTTP #{status}",
+        request_id: nested&.[]('request_id') || body&.[]('request_id') || header_request_id(error),
+        retryable: status == 429 || status >= 500,
+        details: details,
+        charge: paid ? RequestError.fetch_charge(status, code) : 'none'
+      )
+    end
+
+    def parse_details(body)
+      return nil if body.nil? || body.empty?
+
+      parsed = JSON.parse(body)
+      parsed.is_a?(Hash) || parsed.is_a?(Array) ? parsed : nil
+    rescue JSON::ParserError
+      nil
+    end
+
+    def header_request_id(error)
+      headers = error.response_headers
+      return nil unless headers.respond_to?(:each)
+
+      pair = headers.find { |name, _| name.to_s.casecmp?('x-request-id') }
+      value = pair&.last
+      value.is_a?(Array) ? value.first : value
+    end
+  end
+end