pago-sdk 1.0.0

data/lib/pago/serde.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Pago
+  # Sentinel telling an attribute apart from one explicitly set to `nil`.
+  #
+  # Model attributes default to `UNSET`; only the attributes that were given a
+  # value are serialized back to JSON, so a partial update never sends `null`
+  # for the fields it does not touch.
+  UNSET = Object.new
+  def UNSET.inspect = "Pago::UNSET"
+  def UNSET.to_s = "Pago::UNSET"
+  UNSET.freeze
+
+  # JSON conversion helpers shared by every generated model and service.
+  module Serde
+    module_function
+
+    # @return [Hash, nil] the value when it is a JSON object, nil otherwise.
+    def object(data)
+      return nil if data.nil?
+
+      data.is_a?(Hash) ? data : nil
+    end
+
+    # Map a JSON array through the given block, preserving nil.
+    def array(value)
+      return nil if value.nil?
+      return value unless value.is_a?(Array)
+
+      value.map { |item| yield(item) }
+    end
+
+    # Map the values of a JSON object through the given block, preserving nil.
+    def map(value)
+      return nil if value.nil?
+      return value unless value.is_a?(Hash)
+
+      value.each_with_object({}) { |(key, item), result| result[key] = yield(item) }
+    end
+
+    # Recursively convert models, arrays and hashes into JSON-ready values.
+    def dump(value)
+      case value
+      when ::Pago::Model then value.to_json_hash
+      when Array then value.map { |item| dump(item) }
+      when Hash
+        value.each_with_object({}) do |(key, item), result|
+          result[key.is_a?(Symbol) ? key.to_s : key] = dump(item)
+        end
+      when Symbol then value.to_s
+      else value
+      end
+    end
+
+    # Resolve a union payload to one of its variants.
+    #
+    # A discriminated union dispatches on its discriminator property. Otherwise
+    # the candidate models are scored against the payload: a candidate is
+    # eligible only when every key its schema requires is present, and the one
+    # matching the most keys wins. A union whose variants are themselves unions
+    # contributes the variant its own discriminator selects, falling back to all
+    # of them. When nothing matches, the raw payload is returned untouched
+    # rather than raising, so a variant added server side never breaks a client.
+    def union(data, discriminator: nil, mapping: nil, variants: [])
+      return nil if data.nil?
+      return data unless data.is_a?(Hash)
+
+      if discriminator && mapping
+        variant = mapping[data[discriminator]]
+        return variant.from_json(data) if variant.respond_to?(:from_json)
+        return data if data.key?(discriminator)
+      end
+
+      variant = best_variant(data, candidates(data, variants))
+      variant ? variant.from_json(data) : data
+    end
+
+    # @return [Array<Class>] the concrete models a payload could be resolved to.
+    #
+    # A tagged union whose tag the payload carries but this release does not
+    # know contributes nothing: the payload states it is a variant we cannot
+    # name, so scoring it against the variants we do know would mislabel it.
+    def candidates(data, variants, seen = [])
+      variants.flat_map do |variant|
+        if union_module?(variant)
+          next [] if seen.include?(variant)
+
+          nested = dispatch_variant(data, variant)
+          next candidates(data, [nested], seen + [variant]) if nested
+          next [] if tagged?(data, variant)
+
+          candidates(data, variant.variants, seen + [variant])
+        elsif variant.respond_to?(:json_keys)
+          [variant]
+        else
+          []
+        end
+      end
+    end
+
+    # @return [Boolean] whether the payload carries this union's discriminator.
+    def tagged?(data, union_module)
+      return false unless union_module.const_defined?(:DISCRIMINATOR, false)
+
+      discriminator = union_module.const_get(:DISCRIMINATOR)
+      !discriminator.nil? && !union_module.mapping.nil? && data.key?(discriminator)
+    end
+
+    # @return [Class, nil] the variant whose declared keys best match the payload.
+    def best_variant(data, variants)
+      keys = data.keys.map(&:to_s)
+      best = nil
+      best_score = -1
+      variants.each do |variant|
+        next unless variant.respond_to?(:json_keys) && variant.respond_to?(:required_json_keys)
+        next unless (variant.required_json_keys - keys).empty?
+
+        score = (variant.json_keys.values & keys).size
+        if score > best_score
+          best = variant
+          best_score = score
+        end
+      end
+      best
+    end
+
+    # @return [Boolean] whether the variant is a generated union factory module.
+    def union_module?(variant)
+      variant.is_a?(Module) && !variant.is_a?(Class) &&
+        variant.respond_to?(:variants) && variant.respond_to?(:mapping)
+    end
+
+    # @return [Class, Module, nil] the variant a nested union's discriminator selects.
+    def dispatch_variant(data, union_module)
+      return nil unless union_module.const_defined?(:DISCRIMINATOR, false)
+
+      discriminator = union_module.const_get(:DISCRIMINATOR)
+      mapping = union_module.mapping
+      return nil if discriminator.nil? || mapping.nil?
+
+      mapping[data[discriminator]]
+    end
+
+    # Interpolate `{name}` placeholders of a path template.
+    def path(template, params = {})
+      template.gsub(/\{(\w+)\}/) do
+        name = Regexp.last_match(1)
+        value = params[name]
+        raise ::Pago::Error, "Missing value for path parameter #{name.inspect}" if value.nil?
+
+        ::URI.encode_www_form_component(scalar(value)).gsub("+", "%20")
+      end
+    end
+
+    # Flatten query parameters into `[name, value]` pairs.
+    #
+    # Nil values are dropped, arrays repeat the parameter and hashes are encoded
+    # as `name[key]=value`, matching the deep-object style used by the API.
+    def query(params = {})
+      pairs = []
+      params.each do |name, value|
+        next if value.nil?
+
+        case value
+        when Hash
+          value.each do |key, nested|
+            pairs << ["#{name}[#{key}]", scalar(nested)] unless nested.nil?
+          end
+        when Array
+          value.each { |item| pairs << [name.to_s, scalar(item)] unless item.nil? }
+        else
+          pairs << [name.to_s, scalar(value)]
+        end
+      end
+      pairs
+    end
+
+    # @return [String] the query string representation of a scalar value.
+    def scalar(value)
+      case value
+      when Time then value.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      else value.to_s
+      end
+    end
+  end
+end

data/lib/pago/service.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pago
+  # Base class of every generated service.
+  #
+  # Services are thin: they hold the client and build requests. Nested services
+  # share the very same client instance.
+  class Service
+    # @return [Pago::BaseClient]
+    attr_reader :client
+
+    # @param client [Pago::BaseClient]
+    def initialize(client)
+      @client = client
+    end
+  end
+end

data/lib/pago/v2026_04/client.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "services/organizations"
+require_relative "services/subscriptions"
+require_relative "services/oauth2"
+require_relative "services/benefits"
+require_relative "services/benefit_grants"
+require_relative "services/webhooks"
+require_relative "services/products"
+require_relative "services/orders"
+require_relative "services/refunds"
+require_relative "services/disputes"
+require_relative "services/checkouts"
+require_relative "services/files"
+require_relative "services/metrics"
+require_relative "services/license_keys"
+require_relative "services/checkout_links"
+require_relative "services/custom_fields"
+require_relative "services/discounts"
+require_relative "services/customers"
+require_relative "services/members"
+require_relative "services/customer_portal"
+require_relative "services/customer_seats"
+require_relative "services/customer_sessions"
+require_relative "services/events"
+require_relative "services/event_types"
+require_relative "services/meters"
+require_relative "services/customer_meters"
+require_relative "services/payments"
+
+module Pago
+  module V2026_04
+    # Client for version 2026-04 of the Pago API.
+    #
+    # @example
+    #   client = Pago::V2026_04::Client.new(access_token: ENV.fetch("PAGO_ACCESS_TOKEN"))
+    #   client.organizations
+    class Client < ::Pago::BaseClient
+      API_VERSION = "2026-04"
+
+      # @return [Services::Organizations]
+      def organizations = @organizations ||= Services::Organizations.new(self)
+
+      # @return [Services::Subscriptions]
+      def subscriptions = @subscriptions ||= Services::Subscriptions.new(self)
+
+      # @return [Services::Oauth2]
+      def oauth2 = @oauth2 ||= Services::Oauth2.new(self)
+
+      # @return [Services::Benefits]
+      def benefits = @benefits ||= Services::Benefits.new(self)
+
+      # @return [Services::BenefitGrants]
+      def benefit_grants = @benefit_grants ||= Services::BenefitGrants.new(self)
+
+      # @return [Services::Webhooks]
+      def webhooks = @webhooks ||= Services::Webhooks.new(self)
+
+      # @return [Services::Products]
+      def products = @products ||= Services::Products.new(self)
+
+      # @return [Services::Orders]
+      def orders = @orders ||= Services::Orders.new(self)
+
+      # @return [Services::Refunds]
+      def refunds = @refunds ||= Services::Refunds.new(self)
+
+      # @return [Services::Disputes]
+      def disputes = @disputes ||= Services::Disputes.new(self)
+
+      # @return [Services::Checkouts]
+      def checkouts = @checkouts ||= Services::Checkouts.new(self)
+
+      # @return [Services::Files]
+      def files = @files ||= Services::Files.new(self)
+
+      # @return [Services::Metrics]
+      def metrics = @metrics ||= Services::Metrics.new(self)
+
+      # @return [Services::LicenseKeys]
+      def license_keys = @license_keys ||= Services::LicenseKeys.new(self)
+
+      # @return [Services::CheckoutLinks]
+      def checkout_links = @checkout_links ||= Services::CheckoutLinks.new(self)
+
+      # @return [Services::CustomFields]
+      def custom_fields = @custom_fields ||= Services::CustomFields.new(self)
+
+      # @return [Services::Discounts]
+      def discounts = @discounts ||= Services::Discounts.new(self)
+
+      # @return [Services::Customers]
+      def customers = @customers ||= Services::Customers.new(self)
+
+      # @return [Services::Members]
+      def members = @members ||= Services::Members.new(self)
+
+      # @return [Services::CustomerPortal]
+      def customer_portal = @customer_portal ||= Services::CustomerPortal.new(self)
+
+      # @return [Services::CustomerSeats]
+      def customer_seats = @customer_seats ||= Services::CustomerSeats.new(self)
+
+      # @return [Services::CustomerSessions]
+      def customer_sessions = @customer_sessions ||= Services::CustomerSessions.new(self)
+
+      # @return [Services::Events]
+      def events = @events ||= Services::Events.new(self)
+
+      # @return [Services::EventTypes]
+      def event_types = @event_types ||= Services::EventTypes.new(self)
+
+      # @return [Services::Meters]
+      def meters = @meters ||= Services::Meters.new(self)
+
+      # @return [Services::CustomerMeters]
+      def customer_meters = @customer_meters ||= Services::CustomerMeters.new(self)
+
+      # @return [Services::Payments]
+      def payments = @payments ||= Services::Payments.new(self)
+
+    end
+  end
+end