inttegro 1.0.0

data/lib/inttegro/resources/upload_requests.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Inttegro
+  module Resources
+    class UploadRequests
+      def initialize(http)
+        @http = T.let(http, Inttegro::HTTPClient)
+      end
+
+      def create(payload, idempotency_key: nil)
+        @http.post_model(
+          "/upload_requests/create",
+          Inttegro::Models::UploadRequestResponse,
+          payload,
+          headers: headers(idempotency_key)
+        )
+      end
+
+      def lookup(id:)
+        @http.post_model(
+          "/upload_requests/lookup",
+          Inttegro::Models::UploadRequestWithAttemptResponse,
+          { id: id }
+        )
+      end
+
+      def page(payload = {})
+        @http.post_model("/upload_requests/page", Inttegro::Models::UploadRequestPageResponse, payload || {})
+      end
+
+      def cancel(payload, idempotency_key: nil)
+        @http.post_model(
+          "/upload_requests/cancel",
+          Inttegro::Models::UploadRequestResponse,
+          payload,
+          headers: headers(idempotency_key)
+        )
+      end
+
+      def review(payload, idempotency_key: nil)
+        @http.post_model(
+          "/upload_requests/review",
+          Inttegro::Models::UploadRequestWithAttemptResponse,
+          payload,
+          headers: headers(idempotency_key)
+        )
+      end
+
+      def fulfill(upload_url:, file:)
+        @http.post_multipart_model(
+          upload_url,
+          Inttegro::Models::FulfillUploadRequestResponse,
+          files: { file: file },
+          authenticated: false
+        )
+      end
+
+      private
+
+      def headers(idempotency_key)
+        idempotency_key ? { "Idempotency-Key" => idempotency_key } : {}
+      end
+    end
+  end
+end

data/lib/inttegro/response_object.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
+
+require_relative "models"
+require_relative "types"
+
+module Inttegro
+  # Lightweight wrapper for API responses that allows both hash-style and
+  # method-style access while keeping values serializable.
+  class ResponseObject
+    extend T::Sig
+
+    sig { params(data: Types::Payload).void }
+    def initialize(data = {})
+      @data = T.let({}, T::Hash[String, Object])
+      set_data(data)
+    end
+
+    sig { params(key: Types::Key).returns(Object) }
+    def [](key)
+      @data[key.to_s]
+    end
+
+    sig { returns(T::Hash[String, Object]) }
+    def to_h
+      @data.transform_values { |value| deep_unwrap(value) }
+    end
+
+    sig { params(klass: T::Class[T::Struct]).returns(T::Struct) }
+    def deserialize(klass)
+      Inttegro::Models.deserialize(to_h, klass)
+    end
+
+    sig { params(name: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+    def respond_to_missing?(name, include_private = false)
+      @data.key?(name.to_s) || super
+    end
+
+    private
+
+    sig { params(data: Types::Payload).void }
+    def set_data(data)
+      data.each do |key, value|
+        @data[key.to_s] = wrap(value)
+      end
+    end
+
+    sig { params(value: Object).returns(Object) }
+    def wrap(value)
+      case value
+      when Hash
+        self.class.new(value)
+      when Array
+        value.map { |item| wrap(item) }
+      else
+        value
+      end
+    end
+
+    sig { params(value: Object).returns(Object) }
+    def deep_unwrap(value)
+      case value
+      when ResponseObject
+        value.to_h
+      when Hash
+        value.transform_values { |v| deep_unwrap(v) }
+      when Array
+        value.map { |v| deep_unwrap(v) }
+      else
+        value
+      end
+    end
+
+    sig do
+      params(name: Symbol, args: Object, block: T.nilable(Proc)).returns(Object)
+    end
+    def method_missing(name, *args, &block)
+      key = name.to_s
+      return @data[key] if @data.key?(key)
+
+      super
+    end
+  end
+end

data/lib/inttegro/transport_response.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
+
+require_relative "types"
+
+module Inttegro
+  # Normalizes Net::HTTP and custom adapter responses at the SDK boundary.
+  # Adapter objects are deliberately accepted as Object and validated here so
+  # unknown values cannot flow unchecked through the rest of the SDK.
+  class TransportResponse
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :code, :body, :message
+
+    sig { returns(Types::ResponseHeaders) }
+    attr_reader :headers
+
+    sig { params(response: Object).void }
+    def initialize(response)
+      @code = T.let(read_string(response, :code), String)
+      @body = T.let(read_string(response, :body), String)
+      @message = T.let(read_string(response, :message), String)
+      @headers = T.let(normalize_headers(read_headers(response)), Types::ResponseHeaders)
+    end
+
+    sig { params(name: String).returns(T.nilable(String)) }
+    def [](name)
+      pair = @headers.find { |key, _values| key.casecmp?(name) }
+      pair&.last&.first
+    end
+
+    private
+
+    sig { params(response: Object, name: Symbol).returns(String) }
+    def read_string(response, name)
+      unless response.respond_to?(name)
+        raise TypeError, "HTTP adapter response must respond to ##{name}"
+      end
+
+      value = response.public_send(name)
+      value.nil? ? "" : value.to_s
+    end
+
+    sig { params(response: Object).returns(Object) }
+    def read_headers(response)
+      return response.public_send(:headers) if response.respond_to?(:headers)
+      return response.public_send(:to_hash) if response.respond_to?(:to_hash)
+
+      {}
+    end
+
+    sig { params(value: Object).returns(Types::ResponseHeaders) }
+    def normalize_headers(value)
+      return {} unless value.is_a?(Hash)
+
+      value.each_with_object({}) do |(key, header_value), output|
+        values = header_value.is_a?(Array) ? header_value.map(&:to_s) : [header_value.to_s]
+        output[key.to_s] = values
+      end
+    end
+  end
+end

data/lib/inttegro/types.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
+require "net/http"
+require "uri"
+
+module Inttegro
+  # Shared public types used by the SDK's Sorbet signatures.
+  module Types
+    Scalar = T.type_alias { T.any(String, Integer, Float, TrueClass, FalseClass, NilClass) }
+    Key = T.type_alias { T.any(String, Symbol) }
+
+    # Ruby's type system cannot express recursive JSON containers without an
+    # escape hatch. Object is deliberate here: callers must narrow an unknown
+    # wire value before using it, instead of silently disabling checks.
+    Payload = T.type_alias { T::Hash[Key, Object] }
+    Headers = T.type_alias { T::Hash[String, String] }
+    ResponseHeaders = T.type_alias { T::Hash[String, T::Array[String]] }
+    QueryValue = T.type_alias do
+      T.any(Scalar, T::Array[String], T::Array[Integer], T::Array[Float])
+    end
+    Query = T.type_alias { T::Hash[Key, QueryValue] }
+    RequestBody = T.type_alias { T.any(Payload, T::Struct) }
+    WireValue = T.type_alias do
+      T.any(Scalar, T::Enum, T::Struct, Payload, T::Array[Object])
+    end
+    Adapter = T.type_alias do
+      T.proc.params(uri: URI::Generic, request: Net::HTTPRequest).returns(Object)
+    end
+  end
+end

data/lib/inttegro/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Inttegro
+  VERSION = "1.0.0"
+end

data/lib/inttegro.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
+
+require_relative "inttegro/types"
+require_relative "inttegro/client"
+require_relative "inttegro/errors"
+require_relative "inttegro/enums"
+require_relative "inttegro/models"
+require_relative "inttegro/version"
+
+module Inttegro
+end