speakeasy_client_sdk_ruby 1.0.1

data/lib/sdk/schemas.rb

@@ -0,0 +1,334 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'sorbet-runtime'
+
+module SpeakeasyClientSDK
+  extend T::Sig
+  class Schemas
+    extend T::Sig
+    sig { params(sdk: SpeakeasyClientSDK::SDK, client: Faraday::Connection, server_url: String, language: String, sdk_version: String, gen_version: String).void }
+    def initialize(sdk, client, server_url, language, sdk_version, gen_version)
+      @sdk = sdk
+      @client = client
+      @server_url = server_url
+      @language = language
+      @sdk_version = sdk_version
+      @gen_version = gen_version
+    end
+
+    sig { params(request: Operations::DeleteSchemaRequest).returns(Utils::FieldAugmented) }
+    def delete_schema(request)
+      # delete_schema - Delete a particular schema revision for an Api.
+      base_url = @server_url
+      url = Utils.generate_url(
+        Operations::DeleteSchemaRequest,
+        base_url,
+        '/v1/apis/{apiID}/version/{versionID}/schema/{revisionID}',
+        request
+      )
+      headers = {}
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.delete(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::DeleteSchemaResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: Operations::DownloadSchemaRequest).returns(Utils::FieldAugmented) }
+    def download_schema(request)
+      # download_schema - Download the latest schema for a particular apiID.
+      base_url = @server_url
+      url = Utils.generate_url(
+        Operations::DownloadSchemaRequest,
+        base_url,
+        '/v1/apis/{apiID}/version/{versionID}/schema/download',
+        request
+      )
+      headers = {}
+      headers['Accept'] = 'application/json;q=1, application/json;q=0.7, application/x-yaml;q=0'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.get(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::DownloadSchemaResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        res.schema = r.env.response_body if Utils.match_content_type(content_type, 'application/json')
+        res.schema = r.env.response_body if Utils.match_content_type(content_type, 'application/x-yaml')
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: Operations::DownloadSchemaRevisionRequest).returns(Utils::FieldAugmented) }
+    def download_schema_revision(request)
+      # download_schema_revision - Download a particular schema revision for an Api.
+      base_url = @server_url
+      url = Utils.generate_url(
+        Operations::DownloadSchemaRevisionRequest,
+        base_url,
+        '/v1/apis/{apiID}/version/{versionID}/schema/{revisionID}/download',
+        request
+      )
+      headers = {}
+      headers['Accept'] = 'application/json;q=1, application/json;q=0.7, application/x-yaml;q=0'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.get(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::DownloadSchemaRevisionResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        res.schema = r.env.response_body if Utils.match_content_type(content_type, 'application/json')
+        res.schema = r.env.response_body if Utils.match_content_type(content_type, 'application/x-yaml')
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: Operations::GetSchemaRequest).returns(Utils::FieldAugmented) }
+    def get_schema(request)
+      # get_schema - Get information about the latest schema.
+      # Returns information about the last uploaded schema for a particular API version. 
+      # This won't include the schema itself, that can be retrieved via the downloadSchema operation.
+      base_url = @server_url
+      url = Utils.generate_url(
+        Operations::GetSchemaRequest,
+        base_url,
+        '/v1/apis/{apiID}/version/{versionID}/schema',
+        request
+      )
+      headers = {}
+      headers['Accept'] = 'application/json;q=1, application/json;q=0'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.get(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::GetSchemaResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Schema)
+          res.schema = out
+        end
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: Operations::GetSchemaDiffRequest).returns(Utils::FieldAugmented) }
+    def get_schema_diff(request)
+      # get_schema_diff - Get a diff of two schema revisions for an Api.
+      base_url = @server_url
+      url = Utils.generate_url(
+        Operations::GetSchemaDiffRequest,
+        base_url,
+        '/v1/apis/{apiID}/version/{versionID}/schema/{baseRevisionID}/diff/{targetRevisionID}',
+        request
+      )
+      headers = {}
+      headers['Accept'] = 'application/json;q=1, application/json;q=0'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.get(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::GetSchemaDiffResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::SchemaDiff)
+          res.schema_diff = out
+        end
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: Operations::GetSchemaRevisionRequest).returns(Utils::FieldAugmented) }
+    def get_schema_revision(request)
+      # get_schema_revision - Get information about a particular schema revision for an Api.
+      # Returns information about the last uploaded schema for a particular schema revision. 
+      # This won't include the schema itself, that can be retrieved via the downloadSchema operation.
+      base_url = @server_url
+      url = Utils.generate_url(
+        Operations::GetSchemaRevisionRequest,
+        base_url,
+        '/v1/apis/{apiID}/version/{versionID}/schema/{revisionID}',
+        request
+      )
+      headers = {}
+      headers['Accept'] = 'application/json;q=1, application/json;q=0'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.get(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::GetSchemaRevisionResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Schema)
+          res.schema = out
+        end
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: Operations::GetSchemasRequest).returns(Utils::FieldAugmented) }
+    def get_schemas(request)
+      # get_schemas - Get information about all schemas associated with a particular apiID.
+      # Returns information the schemas associated with a particular apiID. 
+      # This won't include the schemas themselves, they can be retrieved via the downloadSchema operation.
+      base_url = @server_url
+      url = Utils.generate_url(
+        Operations::GetSchemasRequest,
+        base_url,
+        '/v1/apis/{apiID}/version/{versionID}/schemas',
+        request
+      )
+      headers = {}
+      headers['Accept'] = 'application/json;q=1, application/json;q=0'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.get(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::GetSchemasResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, T::Array[Shared::Schema])
+          res.schemata = out
+        end
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: Operations::RegisterSchemaRequest).returns(Utils::FieldAugmented) }
+    def register_schema(request)
+      # register_schema - Register a schema.
+      # Allows uploading a schema for a particular API version.
+      # This will be used to populate ApiEndpoints and used as a base for any schema generation if present.
+      base_url = @server_url
+      url = Utils.generate_url(
+        Operations::RegisterSchemaRequest,
+        base_url,
+        '/v1/apis/{apiID}/version/{versionID}/schema',
+        request
+      )
+      headers = {}
+      req_content_type, data, form = Utils.serialize_request_body(request, :request_body, :multipart)
+      headers['content-type'] = req_content_type
+      raise StandardError, 'request body is required' if data.nil? && form.nil?
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.post(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+        if form
+          req.body = Utils.encode_form(form)
+        elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+          req.body = URI.encode_www_form(data)
+        else
+          req.body = data
+        end
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::RegisterSchemaResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+  end
+end

data/lib/sdk/sdk.rb

@@ -0,0 +1,173 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'sorbet-runtime'
+module SpeakeasyClientSDK
+  extend T::Sig
+  SERVER_PROD = 'prod'
+  SERVERS = {
+    SERVER_PROD: 'https://api.prod.speakeasyapi.dev'
+  }.freeze
+  class SDK
+    extend T::Sig
+
+    attr_accessor :api_endpoints, :apis, :embeds, :metadata, :plugins, :requests, :schemas
+
+    attr_accessor :security, :language, :sdk_version, :gen_version
+
+    sig do
+      params(security: Shared::Security,
+             server: String,
+             server_url: String,
+             url_params: T::Hash[Symbol, String],
+             client: Faraday::Request).void
+    end
+    def initialize(security: nil,
+                   server: nil,
+                   server_url: nil,
+                   url_params: nil,
+                   client: nil)
+
+      ## Instantiates the SDK configuring it with the provided parameters.
+      # @param [Shared::Security] security The security details required for authentication
+      # @param [String] server The server by name to use for all operations
+      # @param [String] server_url The server URL to use for all operations
+      # @param [Hash<Symbol, String>] url_params Parameters to optionally template the server URL with
+      # @param [Faraday::Request] client The faraday HTTP client to use for all operations
+
+      @client = Faraday.new(request: {
+                              params_encoder: Faraday::FlatParamsEncoder
+                            }) do |f|
+        f.request :multipart, {}
+        # f.response :logger
+      end
+
+      
+
+
+      @security = nil
+      @server_url = SERVERS[SERVER_PROD]
+      @language = 'ruby'
+      @sdk_version = '1.0.1'
+      @gen_version = '2.35.9'
+      init_sdks
+    end
+
+    sig { params(server_url: String, params: T.nilable(T::Hash[Symbol, String])).void }
+    def config_server_url(server_url, params)
+      if params.nil?
+        @server_url = server_url
+      else
+        @server_url = Utils.template_url(server_url, params)
+      end
+      init_sdks
+    end
+
+    sig { params(server: String, params: T.nilable(T::Hash[Symbol, String])).void }
+    def config_server(server, params)
+      raise StandardError, 'Invalid server' if !SERVERS.include? server
+
+      config_server_url(SERVERS[server], params)
+      init_sdks
+    end
+
+    sig { params(security: Shared::Security).void }
+    def config_security(security)
+      @security = security
+    end
+
+    sig { void }
+    def init_sdks
+      @api_endpoints = ApiEndpoints.new(
+        self,
+        @client,
+        @server_url,
+        @language,
+        @sdk_version,
+        @gen_version
+      )
+      @apis = Apis.new(
+        self,
+        @client,
+        @server_url,
+        @language,
+        @sdk_version,
+        @gen_version
+      )
+      @embeds = Embeds.new(
+        self,
+        @client,
+        @server_url,
+        @language,
+        @sdk_version,
+        @gen_version
+      )
+      @metadata = Metadata.new(
+        self,
+        @client,
+        @server_url,
+        @language,
+        @sdk_version,
+        @gen_version
+      )
+      @plugins = Plugins.new(
+        self,
+        @client,
+        @server_url,
+        @language,
+        @sdk_version,
+        @gen_version
+      )
+      @requests = Requests.new(
+        self,
+        @client,
+        @server_url,
+        @language,
+        @sdk_version,
+        @gen_version
+      )
+      @schemas = Schemas.new(
+        self,
+        @client,
+        @server_url,
+        @language,
+        @sdk_version,
+        @gen_version
+      )
+    end
+
+    
+    sig { returns(Utils::FieldAugmented) }
+    def validate_api_key
+      # validate_api_key - Validate the current api key.
+      base_url = @server_url
+      url = "#{base_url.delete_suffix('/')}/v1/auth/validate"
+      headers = {}
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = "speakeasy-sdk/#{@language} #{@sdk_version} #{@gen_version}"
+
+      r = @client.get(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk.security) if !@sdk.nil? && !@sdk.security.nil?
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::ValidateApiKeyResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::Error)
+          res.error = out
+        end
+      end
+      res
+    end
+  end
+end

data/lib/sdk/utils/metadata_fields.rb

@@ -0,0 +1,154 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module SpeakeasyClientSDK
+  module MetadataFields
+    extend T::Sig
+
+    class Field
+      attr_accessor :name, :type, :metadata
+
+      def initialize(name, type, metadata)
+        @name = name
+        @type = type
+        @metadata = metadata
+      end
+    end
+
+    module ClassMethods
+      extend T::Sig
+
+      def fields
+        @__fields__ = [] if @__fields__.nil?
+
+        @__fields__
+      end
+
+      def field(field_name, type, metadata = {})
+        attr_accessor field_name
+
+        fields << Field.new(field_name, type, metadata)
+      end
+
+      def unmarshal_single(field_type, value, decoder = nil)
+        if field_type.respond_to? :unmarshal_json
+          unmarshalled = field_type.unmarshal_json(value)
+          return unmarshalled
+        elsif field_type.to_s == 'Object'
+          # rubocop:disable Lint/SuppressedException
+          begin
+            value = JSON.parse(value)
+          rescue TypeError, JSON::ParserError
+          end
+          # rubocop:enable Lint/SuppressedException
+          return value
+        end
+        if decoder.nil?
+          value
+        else
+          decoder.call(value)
+        end
+      end
+
+      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(Utils::FieldAugmented) }
+      def unmarshal_json(json_obj)
+        to_build = new
+        begin
+          d = JSON.parse(json_obj)
+        rescue TypeError, JSON::ParserError
+          d = json_obj
+        end
+        fields.each do |field|
+          field_type = field.type
+          if field.type.respond_to?(:types) && field.type.types.length == 2
+            type2 = field.type.types[1]
+            if type2.raw_type == NilClass
+              field_type = field.type.types[0]
+              field_type = field_type.raw_type if field_type.respond_to? :raw_type
+            end
+          end
+
+
+          key = "#{field.name}="
+          lookup = field.metadata.fetch(:format_json, {}).fetch(:letter_case, nil).call
+          value = d[lookup]
+          next if value.nil?
+
+          if field_type.to_s.start_with? 'T::Array'
+            inner_type = field_type.type.raw_type
+            unmarshalled_array = value.map { |f| unmarshal_single(inner_type, f) }
+            to_build.send(key, unmarshalled_array)
+          elsif field_type.to_s.start_with? 'T::Hash'
+            _, val_type = field_type.type.types
+            # rubocop:disable Style/HashTransformValues
+            unmarshalled_hash = value.map { |k, v| [k, unmarshal_single(val_type.raw_type, v)] }.to_h
+            # rubocop:enable Style/HashTransformValues
+            to_build.send(key, unmarshalled_hash)
+          else
+            decoder = field.metadata.fetch(:format_json, {}).fetch(:decoder, nil)
+            final_value = unmarshal_single(field_type, value, decoder)
+            to_build.send(key, final_value)
+          end
+        end
+        to_build
+      end
+    end
+
+    def initialize
+      instance = allocate
+      fields.each { |mod| instance.singleton_class.include(mod) }
+      instance.send(:initialize)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def fields
+      self.class.fields
+    end
+
+    def field(field_name)
+      fields.each do |f|
+        return f if f.name == field_name
+      end
+    end
+
+    def marshal_single(field)
+      if field.respond_to? :marshal_json
+        field.marshal_json(encode: false)
+      else
+        Utils.val_to_string(field, primitives: false)
+      end
+    end
+
+    def marshal_json(encode: true)
+      d = {}
+      fields.sort_by(&:name).each do |field|
+        f = send(field.name)
+        next if f.nil?
+
+        format_json_meta = field.metadata[:format_json]
+        if !format_json_meta.nil? && format_json_meta.include?(:letter_case)
+          key = format_json_meta[:letter_case].call(field.name)
+        else
+          key = field.name
+        end
+        if f.is_a? Array
+          d[key] = f.map { |o| marshal_single(o) }
+        elsif f.is_a? Hash
+          d[key] = f.map { |k, v| [k, marshal_single(v)] }
+        else
+          d[key] = marshal_single(f)
+        end
+      end
+      if encode
+        JSON.dump(d)
+      else
+        d
+      end
+    end
+  end
+end