celitech 2.0.7

data/lib/celitech/http/connection.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'time'
+require 'uri'
+
+module Celitech
+  module HTTP
+    class Connection
+      attr_accessor :default_headers
+      attr_reader :base_url, :timeout, :retry_config
+
+      def base_url=(new_url)
+        new_uri = URI.parse(new_url.chomp('/'))
+        @mutex.synchronize do
+          # A caller-supplied client owns its own connection target; never tear it down
+          # or repoint it. Warn on a host/port change so requests aren't silently sent
+          # to the injected client's original host with the new path.
+          if @custom_http
+            if new_uri.host != @http.address || new_uri.port != @http.port
+              warn '[Celitech] base_url host/port change ignored: a custom ' \
+                   'http_client is in use and keeps its own connection target.'
+            end
+            @base_url = new_url
+            @uri = new_uri
+            next
+          end
+
+          @base_url = new_url
+          @uri = new_uri
+          begin
+            @http&.finish
+          rescue StandardError
+            nil
+          end
+          @http = Net::HTTP.new(@uri.host, @uri.port)
+          @http.use_ssl = @uri.scheme == 'https'
+          if @timeout
+            @http.open_timeout = @timeout
+            @http.read_timeout = @timeout
+          end
+          # Don't call @http.start here — the execute/reconnect path starts it
+          # lazily on the first request, which avoids eager DNS lookups when
+          # switching environments before a request is actually made.
+        end
+      end
+
+      def initialize(base_url, default_headers = {}, timeout: nil, refresh_manager: nil, retry_config: nil, http_client: nil)
+        @base_url        = base_url
+        @timeout         = timeout
+        @retry_config    = retry_config
+        @uri             = URI.parse(base_url.chomp('/'))
+        # A caller-supplied http_client is used as-is: the SDK never reconfigures its
+        # transport (TLS, timeouts, proxy) — the caller owns those settings.
+        @custom_http     = !http_client.nil?
+        @http            = http_client || Net::HTTP.new(@uri.host, @uri.port)
+        @default_headers = { 'User-Agent' => 'postman-codegen/2.6.0 celitech/2.0.7 (ruby)' }.merge(default_headers)
+        @refresh_manager = refresh_manager
+        @mutex           = Mutex.new
+        @hook            = Hooks.new
+        unless @custom_http
+          @http.use_ssl = @uri.scheme == 'https'
+          if timeout
+            @http.open_timeout = timeout
+            @http.read_timeout = timeout
+          end
+        end
+        @http.start unless @http.started?
+      end
+
+      def get(path, params = {}, headers = {})
+        execute(Net::HTTP::Get.new(build_path(path, params), normalize_headers(@default_headers.merge(headers))))
+      end
+
+      def post(path, body = nil, content_type: 'application/json', headers: {})
+        req = Net::HTTP::Post.new(base_path(path), normalize_headers(@default_headers.merge(headers)))
+        set_body(req, body, content_type)
+        execute(req)
+      end
+
+      def put(path, body = nil, content_type: 'application/json', headers: {})
+        req = Net::HTTP::Put.new(base_path(path), normalize_headers(@default_headers.merge(headers)))
+        set_body(req, body, content_type)
+        execute(req)
+      end
+
+      def patch(path, body = nil, content_type: 'application/json', headers: {})
+        req = Net::HTTP::Patch.new(base_path(path), normalize_headers(@default_headers.merge(headers)))
+        set_body(req, body, content_type)
+        execute(req)
+      end
+
+      def delete(path, headers = {})
+        execute(Net::HTTP::Delete.new(base_path(path), normalize_headers(@default_headers.merge(headers))))
+      end
+
+      def head(path, params = {}, headers = {})
+        execute(Net::HTTP::Head.new(build_path(path, params), normalize_headers(@default_headers.merge(headers))))
+      end
+
+      def options(path, params = {}, headers = {})
+        execute(Net::HTTP::Options.new(build_path(path, params), normalize_headers(@default_headers.merge(headers))))
+      end
+
+      def stream_get(path, params = {}, headers = {})
+        stream_execute(Net::HTTP::Get.new(build_path(path, params), normalize_headers(@default_headers.merge(headers))))
+      end
+
+      def stream_post(path, body = nil, content_type: 'application/json', headers: {})
+        req = Net::HTTP::Post.new(base_path(path), normalize_headers(@default_headers.merge(headers)))
+        set_body(req, body, content_type)
+        stream_execute(req)
+      end
+
+      private
+
+      # Connection is opened once in initialize and reused across requests.
+      # If the server closes the socket (idle timeout, restart, etc.) we
+      # transparently reconnect once before giving up.
+      def execute(req)
+        attempts = 0
+        params = {}
+        @hook.before_request(req, params)
+        begin
+          attempts += 1
+          raw = @mutex.synchronize do
+            @http.request(req)
+          rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+            reconnect
+            @http.request(req)
+          end
+          response = Response.new(raw)
+          raise APIError.new(response.status, response.body, response.headers) unless response.success?
+          @hook.after_response(req, response, params)
+          response
+        rescue APIError => e
+          if attempts < (@retry_config&.fetch(:attempts, nil) || 3) && %w[GET POST PUT DELETE PATCH HEAD OPTIONS].include?(req.method.upcase) && (e.status >= 500 || e.status == 408 || e.status == 429)
+            sleep(retry_after_delay(e) || retry_delay(attempts))
+            retry
+          end
+          @hook.on_error(e, req, params)
+          raise
+        end
+      rescue Net::ReadTimeout, Net::OpenTimeout => e
+        raise TimeoutError, e.message
+      end
+
+      def stream_execute(req)
+        Enumerator.new do |yielder|
+          opts = { use_ssl: @uri.scheme == 'https' }
+          if @timeout
+            opts[:open_timeout] = @timeout
+            opts[:read_timeout] = @timeout
+          end
+          params = {}
+          @hook.before_request(req, params)
+          begin
+            Net::HTTP.start(@uri.host, @uri.port, **opts) do |http|
+              http.request(req) do |raw|
+                status = raw.code.to_i
+                unless status >= 200 && status < 300
+                  error = APIError.new(status, raw.read_body, raw.each_header.to_h)
+                  @hook.on_error(error, req, params)
+                  raise error
+                end
+
+                content_type = raw['content-type'].to_s.split(';').first&.strip || ''
+                is_sse = content_type == 'text/event-stream'
+                buffer = +''
+
+                raw.read_body do |chunk|
+                  buffer << chunk
+                  while (idx = buffer.index("\n"))
+                    line = buffer.slice!(0, idx + 1).chomp
+                    if is_sse
+                      next unless line.start_with?('data:')
+
+                      data = line[5..].delete_prefix(' ')
+                      next if data == '[DONE]'
+
+                      yielder << JSON.parse(data)
+                    else
+                      yielder << JSON.parse(line) unless line.empty?
+                    end
+                  end
+                end
+
+                unless buffer.empty?
+                  if is_sse
+                    if buffer.start_with?('data:')
+                      data = buffer[5..].delete_prefix(' ')
+                      yielder << JSON.parse(data) unless data == '[DONE]'
+                    end
+                  else
+                    yielder << JSON.parse(buffer)
+                  end
+                end
+              end
+            end
+          rescue Net::ReadTimeout, Net::OpenTimeout => e
+            raise TimeoutError, e.message
+          end
+        end
+      end
+
+      # Returns seconds to wait before the next retry attempt.
+      # Uses exponential backoff capped at maxDelay, plus random jitter.
+      def retry_delay(attempt)
+        base_ms   = 150 * (2**(attempt - 1))
+        capped_ms = [base_ms, 5000].min
+        jitter_ms = rand(0..50)
+        (capped_ms + jitter_ms) / 1000.0
+      end
+
+      # Honors a server-directed retry delay from rate-limit response headers:
+      # Retry-After (delta-seconds or HTTP-date), or X-RateLimit-Reset (epoch seconds)
+      # when Retry-After is absent. Returns the delay in seconds clamped to
+      # [0, maxRetryAfterDelay], or nil when no usable header is present so the caller
+      # falls back to the computed exponential backoff.
+      def retry_after_delay(error)
+        headers = error.respond_to?(:headers) ? error.headers : nil
+        return nil unless headers.is_a?(Hash)
+
+        max_s = 60_000 / 1000.0
+        return nil unless max_s.positive?
+
+        # Normalize keys to lowercase hyphenated strings so lookups are robust to
+        # header casing and symbol keys regardless of how the error was constructed.
+        normalized = headers.each_with_object({}) do |(k, v), acc|
+          acc[k.to_s.downcase.tr('_', '-')] = v
+        end
+
+        # retry-after-ms (milliseconds) is a non-standard but finer-grained hint some
+        # APIs send (e.g. OpenAI); it takes precedence over the whole-second Retry-After.
+        ms = normalized['retry-after-ms'].to_s.strip
+        return (ms.to_f / 1000.0).clamp(0.0, max_s) if ms.match?(/\A\d+(\.\d+)?\z/)
+
+        seconds = parse_retry_after(normalized['retry-after'])
+        return seconds.clamp(0.0, max_s) unless seconds.nil?
+
+        # X-RateLimit-Reset is interpreted as epoch seconds (the common convention).
+        reset = normalized['x-ratelimit-reset']
+        unless reset.nil? || reset.to_s.strip.empty?
+          seconds = reset.to_f - Time.now.to_f
+          return seconds.clamp(0.0, max_s) if seconds.positive?
+        end
+        nil
+      end
+
+      # Parses a Retry-After header value: an integer/float number of seconds, or an
+      # HTTP-date. Returns the delay in seconds (Float) or nil if unparseable.
+      def parse_retry_after(value)
+        return nil if value.nil?
+
+        str = value.to_s.strip
+        return nil if str.empty?
+        return str.to_f if str.match?(/\A\d+(\.\d+)?\z/)
+
+        begin
+          Time.httpdate(str).to_f - Time.now.to_f
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      # Collapses array header values into a comma-separated string.
+      # Matches OpenAPI style=simple, explode=false (the default for header parameters).
+      def normalize_headers(hdrs)
+        return hdrs unless hdrs.any? { |_, v| v.is_a?(Array) }
+
+        hdrs.transform_values { |v| v.is_a?(Array) ? v.join(',') : v }
+      end
+
+      def reconnect
+        begin
+          @http.finish
+        rescue StandardError
+          nil
+        end
+        @http.start
+      end
+
+      def set_body(req, body, content_type)
+        return unless body
+
+        case content_type
+        when /json/
+          req.body = Serializers::Json.serialize(body).to_json
+          req['Content-Type'] = content_type
+        when 'application/xml'
+          req.body = Serializers::Xml.serialize(body)
+          req['Content-Type'] = 'application/xml'
+        when 'application/x-www-form-urlencoded'
+          req.body = Serializers::Form.to_urlencoded(body)
+          req['Content-Type'] = 'application/x-www-form-urlencoded'
+        when 'multipart/form-data'
+          Serializers::Form.set_multipart(req, body)
+        when %r{^text/}
+          req.body = body.to_s
+          req['Content-Type'] = content_type
+        else
+          # Binary and other raw types
+          req.body = body.respond_to?(:read) ? body.read : body.to_s
+          req['Content-Type'] = content_type
+        end
+      end
+
+      def base_path(path)
+        "#{@uri.path.chomp('/')}#{path}"
+      end
+
+      def build_path(path, params)
+        return base_path(path) if params.nil? || params.empty?
+
+        query = params.is_a?(Hash) ? URI.encode_www_form(params) : params
+        "#{base_path(path)}?#{query}"
+      end
+    end
+  end
+end

data/lib/celitech/http/hooks.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Celitech
+  module HTTP
+    # Lifecycle hooks for intercepting HTTP requests and responses.
+    # Override these methods in a subclass to add custom behaviour.
+    # Hook implementations should not raise exceptions; uncaught errors
+    # will propagate out of the connection and bypass subsequent hooks.
+    class Hooks
+      def before_request(request, params = {}); end
+
+      def after_response(request, response, params = {}); end
+
+      def on_error(error, request, params = {}); end
+    end
+  end
+end

data/lib/celitech/http/oauth_token_manager.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Celitech
+  module HTTP
+    class OAuthError < StandardError; end
+
+    # Manages OAuth 2.0 client credentials tokens: fetches, caches, and refreshes them.
+    # Token refresh is triggered when the token is absent or within REFRESH_BUFFER_SECS
+    # of expiry. A Mutex ensures thread-safe access to the cached token.
+    # Note: token refresh blocks all threads calling `headers` until the HTTP request
+    # completes. This is intentional — only one fetch occurs and others reuse the result.
+    class OAuthTokenManager
+      REFRESH_BUFFER_SECS = 5
+
+      def initialize(client_id:, client_secret:, token_url:)
+        @client_id     = client_id
+        @client_secret = client_secret
+        @token_url     = token_url
+        @access_token  = nil
+        @expires_at    = nil
+        @mutex         = Mutex.new
+      end
+
+      attr_writer :client_id, :client_secret
+
+      def headers
+        { 'Authorization' => "Bearer #{token}" }
+      end
+
+      # Force the next call to re-fetch a fresh token.
+      def invalidate
+        @mutex.synchronize { @access_token = nil }
+      end
+
+      private
+
+      def token
+        @mutex.synchronize do
+          fetch_token if token_expired?
+          @access_token
+        end
+      end
+
+      def token_expired?
+        @access_token.nil? || (@expires_at && Time.now + REFRESH_BUFFER_SECS >= @expires_at)
+      end
+
+      def fetch_token
+        uri = URI.parse(@token_url)
+        req = Net::HTTP::Post.new(uri.request_uri)
+        req.set_form_data(
+          grant_type: 'client_credentials',
+          client_id: @client_id,
+          client_secret: @client_secret,
+        )
+
+        # Net::HTTP.start with a block opens and closes the connection automatically.
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(req)
+        end
+        raise OAuthError, "token request failed (HTTP #{response.code}): #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        body = JSON.parse(response.body)
+        raise OAuthError, 'access_token missing from token response' unless body.key?('access_token')
+
+        @access_token = body['access_token']
+        expires_in    = body['expires_in']
+        @expires_at   = expires_in ? Time.now + expires_in.to_i : nil
+      end
+    end
+  end
+end

data/lib/celitech/http/response.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Celitech
+  module HTTP
+    class Response
+      attr_reader :status, :headers, :body, :raw_body
+
+      def initialize(raw)
+        @status   = raw.code.to_i
+        @headers  = raw.each_header.to_h
+        @raw_body = raw.body
+        @body     = parse_body(raw.body, @headers['content-type'])
+      end
+
+      def success?
+        status >= 200 && status < 300
+      end
+
+      private
+
+      def parse_body(raw_body, content_type)
+        return nil if raw_body.nil? || raw_body.empty?
+
+        ct = content_type.to_s.split(';').first&.strip || ''
+        return JSON.parse(raw_body) if ct.include?('json')
+        return raw_body             if ct.start_with?('text/') || ct == 'application/xml'
+
+        # For binary and unknown types try JSON first, fall back to raw
+        JSON.parse(raw_body)
+      rescue JSON::ParserError
+        raw_body
+      end
+    end
+  end
+end

data/lib/celitech/models/bad_request.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Celitech
+  module Models
+    class BadRequest
+      include ::Celitech::Models::Serializable
+      include ::Celitech::Models::OpenModel
+
+      def self.wire_keys
+        {
+          message: 'message',
+        }.freeze
+      end
+
+      def message
+        val = @message
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      attr_reader :additional_properties
+
+      def initialize(message: ::Celitech::Models::UNSET, additional_properties: {})
+        @message = message
+        @additional_properties = additional_properties
+      end
+
+      def self.from_hash(hash)
+        return unless hash
+
+        new(
+          message: hash.fetch('message', ::Celitech::Models::UNSET),
+          additional_properties: hash.except('message'),
+        )
+      end
+
+      def attributes
+        {
+          message: @message,
+        }
+      end
+
+      def open_model_extras
+        @additional_properties
+      end
+    end
+  end
+end

data/lib/celitech/models/create_purchase_ok_response.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Celitech
+  module Models
+    class CreatePurchaseOkResponse
+      include ::Celitech::Models::Serializable
+      include ::Celitech::Models::OpenModel
+
+      def self.wire_keys
+        {
+          purchase: 'purchase',
+          profile: 'profile',
+        }.freeze
+      end
+
+      def purchase
+        val = @purchase
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def profile
+        val = @profile
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      attr_reader :additional_properties
+
+      def initialize(purchase: ::Celitech::Models::UNSET, profile: ::Celitech::Models::UNSET, additional_properties: {})
+        @purchase = purchase
+        @profile = profile
+        @additional_properties = additional_properties
+      end
+
+      def self.from_hash(hash)
+        return unless hash
+
+        new(
+          purchase:
+            hash.key?('purchase') ? ::Celitech::Models::CreatePurchaseOkResponsePurchase.from_hash(hash['purchase']) : ::Celitech::Models::UNSET,
+          profile:
+            hash.key?('profile') ? ::Celitech::Models::CreatePurchaseOkResponseProfile.from_hash(hash['profile']) : ::Celitech::Models::UNSET,
+          additional_properties: hash.except('purchase', 'profile'),
+        )
+      end
+
+      def attributes
+        {
+          purchase: @purchase,
+          profile: @profile,
+        }
+      end
+
+      def validate!
+        @purchase&.validate! if !@purchase.equal?(::Celitech::Models::UNSET) && @purchase.respond_to?(:validate!)
+        @profile&.validate! if !@profile.equal?(::Celitech::Models::UNSET) && @profile.respond_to?(:validate!)
+      end
+
+      def open_model_extras
+        @additional_properties
+      end
+    end
+  end
+end

data/lib/celitech/models/create_purchase_ok_response_profile.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Celitech
+  module Models
+    class CreatePurchaseOkResponseProfile
+      include ::Celitech::Models::Serializable
+      include ::Celitech::Models::OpenModel
+
+      def self.wire_keys
+        {
+          iccid: 'iccid',
+          activation_code: 'activationCode',
+          manual_activation_code: 'manualActivationCode',
+        }.freeze
+      end
+
+      def iccid
+        val = @iccid
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def activation_code
+        val = @activation_code
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      def manual_activation_code
+        val = @manual_activation_code
+        val.equal?(::Celitech::Models::UNSET) ? nil : val
+      end
+
+      attr_reader :additional_properties
+
+      def initialize(
+        iccid: ::Celitech::Models::UNSET,
+        activation_code: ::Celitech::Models::UNSET,
+        manual_activation_code: ::Celitech::Models::UNSET,
+        additional_properties: {}
+      )
+        @iccid = iccid
+        @activation_code = activation_code
+        @manual_activation_code = manual_activation_code
+        @additional_properties = additional_properties
+      end
+
+      def self.from_hash(hash)
+        return unless hash
+
+        new(
+          iccid: hash.fetch('iccid', ::Celitech::Models::UNSET),
+          activation_code: hash.fetch('activationCode', ::Celitech::Models::UNSET),
+          manual_activation_code: hash.fetch('manualActivationCode', ::Celitech::Models::UNSET),
+          additional_properties: hash.except('iccid', 'activationCode', 'manualActivationCode'),
+        )
+      end
+
+      def attributes
+        {
+          iccid: @iccid,
+          activation_code: @activation_code,
+          manual_activation_code: @manual_activation_code,
+        }
+      end
+
+      def validate!
+        Validator.validate_string!(@iccid, 'iccid', min_length: 18, max_length: 22) unless @iccid.equal?(::Celitech::Models::UNSET)
+        Validator.validate_string!(@activation_code, 'activationCode', min_length: 1000, max_length: 8000) unless @activation_code.equal?(::Celitech::Models::UNSET)
+      end
+
+      def open_model_extras
+        @additional_properties
+      end
+    end
+  end
+end