fsdk-2237-ruby-e2e 0.1.0

data/lib/petstore/internal/types/utils.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Petstore
+  module Internal
+    module Types
+      # Utilities for dealing with and checking types
+      module Utils
+        # Wraps a type into a type function
+        #
+        # @param type [Proc, Object]
+        # @return [Proc]
+        def self.wrap_type(type)
+          case type
+          when Proc
+            type
+          else
+            -> { type }
+          end
+        end
+
+        # Resolves a type or type function into a type
+        #
+        # @param type [Proc, Object]
+        # @return [Object]
+        def self.unwrap_type(type)
+          type.is_a?(Proc) ? type.call : type
+        end
+
+        def self.coerce(target, value, strict: false)
+          type = unwrap_type(target)
+
+          case type
+          in Array
+            case value
+            when ::Array
+              return type.coerce(value, strict: strict)
+            when Set, ::Hash
+              return coerce(type, value.to_a)
+            end
+          in Hash
+            case value
+            when ::Hash
+              return type.coerce(value, strict: strict)
+            when ::Array
+              return coerce(type, value.to_h)
+            end
+          in ->(t) { t <= NilClass }
+            return nil
+          in ->(t) { t <= String }
+            case value
+            when String, Symbol, Numeric, TrueClass, FalseClass
+              return value.to_s
+            end
+          in ->(t) { t <= Symbol }
+            case value
+            when Symbol, String
+              return value.to_sym
+            end
+          in ->(t) { t <= Integer }
+            case value
+            when Numeric, String, Time
+              return value.to_i
+            end
+          in ->(t) { t <= Float }
+            case value
+            when Numeric, Time, String
+              return value.to_f
+            end
+          in ->(t) { t <= Model }
+            case value
+            when type
+              return value
+            when ::Hash
+              return type.coerce(value, strict: strict)
+            end
+          in Module
+            case type
+            in ->(t) {
+                 t.singleton_class.include?(Enum) ||
+                   t.singleton_class.include?(Union)
+               }
+              return type.coerce(value, strict: strict)
+            else
+              value # rubocop:disable Lint/Void
+            end
+          else
+            value # rubocop:disable Lint/Void
+          end
+
+          raise Errors::TypeError, "cannot coerce value of type `#{value.class}` to `#{target}`" if strict
+
+          value
+        end
+
+        def self.symbolize_keys(hash)
+          hash.transform_keys(&:to_sym)
+        end
+
+        # Converts camelCase keys to snake_case symbols
+        # This allows SDK methods to accept both snake_case and camelCase keys
+        # e.g., { refundMethod: ... } becomes { refund_method: ... }
+        #
+        # @param hash [Hash]
+        # @return [Hash]
+        # Serializes a header parameter using OpenAPI "simple" style (RFC 6570 section 3.2.2),
+        # which is the default for `in: header`. `to_s` alone is wrong for anything but a
+        # primitive: an array would reach the wire as Ruby's inspect form (`["a", "b"]`) and a
+        # hash as `{"k" => "v"}`, neither of which a server can parse.
+        def self.simple_param(value)
+          case value
+          when nil then nil
+          when ::Array then value.map { |v| v.nil? ? '' : v.to_s }.join(',')
+          when ::Hash then value.flat_map { |k, v| [k.to_s, v.to_s] }.join(',')
+          else value.to_s
+          end
+        end
+
+        # Serializes a cookie parameter value. Percent-encoded because `;` and `,` are delimiters
+        # in a Cookie header, so an unencoded value can inject additional cookies.
+        def self.cookie_param(value)
+          ::CGI.escape(simple_param(value).to_s)
+        end
+
+        def self.normalize_keys(hash)
+          hash.transform_keys do |key|
+            key_str = key.to_s
+            # Convert camelCase to snake_case
+            snake_case = key_str.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+            snake_case.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/petstore/models/open_model.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Models
+    # Marker module for open object models (additionalProperties: true).
+    #
+    # Including classes must implement:
+    #   - #open_model_extras → Hash of extra key/value pairs captured from deserialization
+    #
+    # In return, this module overrides +#to_h+ to merge the extras into the
+    # symbol-keyed hash produced by +Serializable#to_h+, so round-trips through
+    # JSON preserve unknown fields without requiring schema changes.
+    #
+    # +#to_h+ is a symbol-keyed Ruby view: declared fields keep their attribute names and win
+    # on collision. +Serializers::Json.serialize+ is the wire-faithful path (keeps raw wire
+    # keys) and is what guarantees the unknown-field round-trip.
+    module OpenModel
+      def open_model_extras
+        raise NotImplementedError, "#{self.class} must implement #open_model_extras"
+      end
+
+      def to_h
+        extras = open_model_extras
+        return super if extras.nil? || extras.empty?
+
+        extras.transform_keys(&:to_sym).merge(super)
+      end
+    end
+  end
+end

data/lib/petstore/models/serializable.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Models
+    # Sentinel value for model fields that were never explicitly set.
+    # Distinguishes "field not provided" from "field explicitly set to nil",
+    # which matters for PATCH requests where nil means "clear this field".
+    UNSET = Object.new.tap do |o|
+      o.define_singleton_method(:inspect) { 'UNSET' }
+      o.define_singleton_method(:to_s) { 'UNSET' }
+    end.freeze
+
+    # Marker module for generated model classes.
+    #
+    # Including classes must implement:
+    #   - .wire_keys → { attr_sym: 'wire_name', ... }.freeze
+    #   - .from_hash(hash) → model instance or nil
+    #   - #attributes → { attr_sym: raw_value, ... }
+    #
+    # In return, this module provides:
+    #   - #to_h → { attr_sym: value, ... } with nested models recursively converted,
+    #             omitting fields set to UNSET but preserving explicit nil
+    module Serializable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def wire_keys
+          raise NotImplementedError, "#{name} must implement .wire_keys"
+        end
+
+        def from_hash(_hash)
+          raise NotImplementedError, "#{name} must implement .from_hash"
+        end
+      end
+
+      def to_h
+        self.class.wire_keys.each_with_object({}) do |(attr, _key), hash|
+          val = attributes[attr]
+          next if val.equal?(UNSET)
+
+          hash[attr] = coerce_to_h(val)
+        end
+      end
+
+      def attributes
+        raise NotImplementedError, "#{self.class} must implement #attributes"
+      end
+
+      private
+
+      def coerce_to_h(val)
+        return val.to_h if val.is_a?(Serializable)
+        return val.map { |item| coerce_to_h(item) } if val.is_a?(Array)
+        # Typed maps (additionalProperties): recurse values, preserving the dynamic string keys.
+        return val.transform_values { |item| coerce_to_h(item) } if val.is_a?(Hash)
+
+        val
+      end
+    end
+  end
+end

data/lib/petstore/models/union_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Models
+    # Marker module for oneOf/anyOf union wrapper classes.
+    #
+    # Including classes hold one typed variant in +#value+.
+    # Serializers check for this module to delegate serialization to the wrapped value.
+    module UnionType
+    end
+  end
+end

data/lib/petstore/pet/client.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Petstore
+  module Pet
+    class Client
+      def initialize(client:)
+        @client = client
+      end
+
+      def add_pet(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request_body = ::Petstore::Pet::Types::Pet.new(params)
+        request_body.validate! if request_body.respond_to?(:validate!)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'POST',
+          path: 'pet',
+          body: request_body.to_h,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Pet::Types::Pet.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def update_pet(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request_body = ::Petstore::Pet::Types::Pet.new(params)
+        request_body.validate! if request_body.respond_to?(:validate!)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'PUT',
+          path: 'pet',
+          body: request_body.to_h,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Pet::Types::Pet.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def find_pets_by_status(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params['status'] = params[:status] if params.key?(:status)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'GET',
+          path: 'pet/findByStatus',
+          query: query_params,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Internal::Types::Array[::Petstore::Pet::Types::Pet].coerce(::JSON.parse(body, symbolize_names: false)) }
+          result&.each { |item| item.validate! if item.respond_to?(:validate!) }
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def find_pets_by_tags(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params['tags'] = params[:tags] if params.key?(:tags)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'GET',
+          path: 'pet/findByTags',
+          query: query_params,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Internal::Types::Array[::Petstore::Pet::Types::Pet].coerce(::JSON.parse(body, symbolize_names: false)) }
+          result&.each { |item| item.validate! if item.respond_to?(:validate!) }
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def get_pet_by_id(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'GET',
+          path: "pet/#{URI.encode_uri_component(params[:pet_id].to_s)}",
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Pet::Types::Pet.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def update_pet_with_form(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params['name'] = params[:name] if params.key?(:name)
+        query_params['status'] = params[:status] if params.key?(:status)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'POST',
+          path: "pet/#{URI.encode_uri_component(params[:pet_id].to_s)}",
+          query: query_params,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Pet::Types::Pet.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def delete_pet(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        headers = {}
+        headers['api_key'] = ::Petstore::Internal::Types::Utils.simple_param(params[:api_key]) if params.key?(:api_key)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'DELETE',
+          path: "pet/#{URI.encode_uri_component(params[:pet_id].to_s)}",
+          headers: headers,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+
+      # @param body [String, #read] The request body, sent verbatim as `application/octet-stream`.
+      #   Pass it as the `body:` keyword; it is not read from a request model.
+      def upload_file(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params['additionalMetadata'] = params[:additional_metadata] if params.key?(:additional_metadata)
+        request = ::Petstore::Internal::Raw::Request.new(
+          base_url: request_options[:base_url],
+          method: 'POST',
+          path: "pet/#{URI.encode_uri_component(params[:pet_id].to_s)}/uploadImage",
+          query: query_params,
+          body: params[:body],
+          content_type: 'application/octet-stream',
+          accept: 'application/json',
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Types::APIResponse.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/petstore/pet/types/delete_pet_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Pet
+    module Types
+      class DeletePetRequest < ::Petstore::Internal::Types::Model
+        field :pet_id, -> { Integer }, optional: false, nullable: false, api_name: 'petId'
+
+        field :api_key, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/petstore/pet/types/find_pets_by_status_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Pet
+    module Types
+      class FindPetsByStatusRequest < ::Petstore::Internal::Types::Model
+        field :status, -> { ::Petstore::Pet::Types::FindPetsByStatusRequestStatus }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/petstore/pet/types/find_pets_by_status_request_status.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Pet
+    module Types
+      module FindPetsByStatusRequestStatus
+        extend ::Petstore::Internal::Types::Enum
+
+        AVAILABLE = :available
+        PENDING = :pending
+        SOLD = :sold
+
+        def self.load(str)
+          coerce(::JSON.parse(str, symbolize_names: true))
+        end
+
+        def self.dump(value)
+          coerced = coerce(value)
+          ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/petstore/pet/types/find_pets_by_tags_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Pet
+    module Types
+      class FindPetsByTagsRequest < ::Petstore::Internal::Types::Model
+        field :tags, -> { ::Petstore::Internal::Types::Array[String] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/petstore/pet/types/get_pet_by_id_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Pet
+    module Types
+      class GetPetByIDRequest < ::Petstore::Internal::Types::Model
+        field :pet_id, -> { Integer }, optional: false, nullable: false, api_name: 'petId'
+      end
+    end
+  end
+end

data/lib/petstore/pet/types/pet.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Pet
+    module Types
+      class Pet < ::Petstore::Internal::Types::Model
+        field :id, -> { Integer }, optional: true, nullable: false
+        field :name, -> { String }, optional: false, nullable: false
+        field :category, -> { ::Petstore::Types::Category }, optional: true, nullable: false
+        field :photo_urls, -> { ::Petstore::Internal::Types::Array[String] }, optional: false, nullable: false, api_name: 'photoUrls'
+        field :tags, -> { ::Petstore::Internal::Types::Array[::Petstore::Types::Tag] }, optional: true, nullable: false
+        field :status, -> { ::Petstore::Types::PetStatus }, optional: true, nullable: false
+
+        def self.load(str)
+          coerce(::JSON.parse(str, symbolize_names: true))
+        end
+
+        def self.dump(value)
+          coerced = coerce(value)
+          ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/petstore/pet/types/update_pet_with_form_request.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Pet
+    module Types
+      class UpdatePetWithFormRequest < ::Petstore::Internal::Types::Model
+        field :pet_id, -> { Integer }, optional: false, nullable: false, api_name: 'petId'
+
+        field :name, -> { String }, optional: true, nullable: false
+
+        field :status, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/petstore/serializers/form_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Petstore
+  module Serializers
+    # Serializes models or hashes to form-encoded and multipart bodies.
+    module Form
+      # Encodes a model or hash as application/x-www-form-urlencoded.
+      def self.to_urlencoded(value)
+        URI.encode_www_form(flatten(value))
+      end
+
+      # Configures a Net::HTTP request for multipart/form-data.
+      def self.set_multipart(request, value)
+        request.set_form(
+          flatten(value).map { |k, v| [k.to_s, v.to_s] },
+          'multipart/form-data',
+        )
+      end
+
+      private_class_method def self.flatten(value)
+        value = value.value if value.is_a?(Models::UnionType)
+        if value.is_a?(Models::Serializable)
+          declared = value.class.wire_keys.filter_map do |attr, key|
+            val = value.attributes[attr]
+            # Form encoding cannot represent null; both UNSET and explicit nil are omitted.
+            # Unlike JSON (which serializes nil as null), form bodies have no null concept.
+            [key, val] unless val.nil? || val.equal?(Models::UNSET)
+          end
+          extras = value.is_a?(Models::OpenModel) ? value.open_model_extras.compact.to_a : []
+          declared + extras
+        elsif value.is_a?(Hash)
+          value.compact.to_a
+        else
+          [['body', value.to_s]]
+        end
+      end
+    end
+  end
+end

data/lib/petstore/serializers/json_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Petstore
+  module Serializers
+    # Serializes models to JSON-ready hashes and deserializes hashes back to models.
+    module Json
+      # Converts a model, array, or primitive to a plain Ruby hash/value
+      # suitable for JSON.generate / .to_json.
+      def self.serialize(value)
+        return value.map { |item| serialize(item) } if value.is_a?(Array)
+        # Typed maps (additionalProperties): serialize values, keeping the dynamic string keys.
+        return value.transform_values { |item| serialize(item) } if value.is_a?(Hash)
+        return serialize(value.value) if value.is_a?(Models::UnionType)
+        return serialize_model(value) if value.is_a?(Models::Serializable)
+
+        value
+      end
+
+      # Builds a model instance from a plain hash (already JSON.parsed).
+      # Returns the raw data unchanged when no model class is provided.
+      def self.deserialize(data, model_class = nil)
+        return data unless model_class
+
+        model_class.from_hash(data)
+      end
+
+      private_class_method def self.serialize_model(model)
+        result = model.class.wire_keys.each_with_object({}) do |(attr, key), hash|
+          val = model.attributes[attr]
+          next if val.equal?(Models::UNSET)
+
+          hash[key] = serialize(val)
+        end
+        model.open_model_extras.each { |k, v| result[k] = serialize(v) unless result.key?(k) } if model.is_a?(Models::OpenModel)
+        result
+      end
+    end
+  end
+end