noresponse 2.0.17

data/lib/no_response/noresponseclient.rb

@@ -0,0 +1,110 @@
+# typed: true
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "faraday/retry"
+require "sorbet-runtime"
+
+require_relative "sdk_hooks/hooks"
+require_relative "utils/retries"
+
+module NoResponse
+  extend T::Sig
+
+  class NoResponseClient
+    extend T::Sig
+
+    attr_accessor :assessments, :keys
+
+    # Instantiates the SDK, configuring it with the provided parameters.
+    #
+    # @param client [Faraday::Connection, nil] The faraday HTTP client to use for all operations
+    # @param retry_config [::NoResponse::Utils::RetryConfig, nil] The retry configuration to use for all operations
+    # @param timeout_ms [Integer, nil] Request timeout in milliseconds for all operations
+    # @param security [Models::Shared::Security, nil] The security details required for authentication
+    # @param security_source [Proc{|| Models::Shared::Security, nil}] A function that returns security details required for authentication
+    # @param server_idx [Integer, nil] The index of the server to use for all operations
+    # @param server_url [String, nil] The server URL to use for all operations
+    # @param url_params [Hash{Symbol => String}, nil] Parameters to optionally template the server URL with
+    sig do
+      params(
+        client: T.nilable(Faraday::Connection),
+        retry_config: T.nilable(::NoResponse::Utils::RetryConfig),
+        timeout_ms: T.nilable(Integer),
+        api_key: T.nilable(::String),
+        security_source: T.nilable(T.proc.returns(Models::Shared::Security)),
+        server_idx: T.nilable(Integer),
+        server_url: T.nilable(String),
+        url_params: T.nilable(T::Hash[Symbol, String])
+      )
+        .void
+    end
+    def initialize(
+      client: nil,
+      retry_config: nil,
+      timeout_ms: nil,
+      api_key: nil,
+      security_source: nil,
+      server_idx: nil,
+      server_url: nil,
+      url_params: nil
+    )
+
+      connection_options = {
+        request: {
+          params_encoder: Faraday::FlatParamsEncoder
+        }
+      }
+      connection_options[:request][:timeout] = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+
+      client ||= Faraday.new(**connection_options) do |f|
+        f.request(:multipart, {flat_encode: true})
+        # f.response :logger, nil, { headers: true, bodies: true, errors: true }
+      end
+
+      if !server_url.nil?
+        if !url_params.nil?
+          server_url = Utils.template_url(server_url, url_params)
+        end
+      end
+
+      server_idx = 0 if server_idx.nil?
+      hooks = SDKHooks::Hooks.new
+      @sdk_configuration = SDKConfiguration.new(
+        client,
+        hooks,
+        retry_config,
+        timeout_ms,
+        api_key,
+        security_source,
+        server_url,
+        server_idx
+      )
+      @sdk_configuration = hooks.sdk_init(config: @sdk_configuration)
+      init_sdks
+    end
+
+    sig { void }
+    def init_sdks
+      @assessments = Assessments.new(@sdk_configuration)
+      @keys = Keys.new(@sdk_configuration)
+    end
+
+    sig { params(base_url: String, url_variables: T.nilable(T::Hash[Symbol, T.any(String, T::Enum)])).returns(String) }
+    def get_url(base_url:, url_variables: nil)
+      sd_base_url, sd_options = @sdk_configuration.get_server_details
+
+      if base_url.nil?
+        base_url = sd_base_url
+      end
+
+      if url_variables.nil?
+        url_variables = sd_options
+      end
+
+      return Utils.template_url(base_url, url_variables)
+    end
+
+  end
+end

data/lib/no_response/sdk_hooks/hooks.rb

@@ -0,0 +1,97 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "./types"
+require_relative "./registration"
+
+module NoResponse
+  module SDKHooks
+    class Hooks
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        @sdk_init_hooks = T.let([], T::Array[AbstractSDKHook])
+        @before_request_hooks = T.let([], T::Array[AbstractSDKHook])
+        @after_success_hooks = T.let([], T::Array[AbstractSDKHook])
+        @after_error_hooks = T.let([], T::Array[AbstractSDKHook])
+        Registration.init_hooks(self)
+      end
+
+      sig { params(hook: AbstractSDKHook).void }
+      def register_sdk_init_hook(hook)
+        @sdk_init_hooks << hook
+      end
+
+      sig { params(hook: AbstractSDKHook).void }
+      def register_before_request_hook(hook)
+        @before_request_hooks << hook
+      end
+
+      sig { params(hook: AbstractSDKHook).void }
+      def register_after_success_hook(hook)
+        @after_success_hooks << hook
+      end
+
+      sig { params(hook: AbstractSDKHook).void }
+      def register_after_error_hook(hook)
+        @after_error_hooks << hook
+      end
+
+      sig { params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
+        @sdk_init_hooks.each do |hook|
+          config = hook.sdk_init(config: config)
+        end
+
+        return config
+      end
+
+      sig do
+        params(
+          hook_ctx: BeforeRequestHookContext,
+          request: Faraday::Request
+        )
+          .returns(Faraday::Request)
+      end
+      def before_request(hook_ctx:, request:)
+        @before_request_hooks.each do |hook|
+          request = hook.before_request(hook_ctx: hook_ctx, request: request)
+        end
+
+        request
+      end
+
+      sig do
+        params(
+          hook_ctx: AfterSuccessHookContext,
+          response: Faraday::Response
+        )
+          .returns(Faraday::Response)
+      end
+      def after_success(hook_ctx:, response:)
+        @after_success_hooks.each do |hook|
+          response = hook.after_success(hook_ctx: hook_ctx, response: response)
+        end
+
+        response
+      end
+
+      sig do
+        params(
+          error: T.nilable(StandardError),
+          hook_ctx: AfterErrorHookContext,
+          response: T.nilable(Faraday::Response)
+        )
+          .returns(T.nilable(Faraday::Response))
+      end
+      def after_error(error:, hook_ctx:, response:)
+        @after_error_hooks.each do |hook|
+          response = hook.after_error(error: error, hook_ctx: hook_ctx, response: response)
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/no_response/sdk_hooks/idempotency_key_hook.rb

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module NoResponse
+  module SDKHooks
+    # Sends a fresh UUID as the Idempotency-Key when the caller gave none. The
+    # hook runs once per call, before any retry, so every attempt carries the
+    # same key.
+    class IdempotencyKeyHook < AbstractSDKHook
+      extend T::Sig
+
+      OPERATIONS = %w[createAssessment recordAssessmentOutcome].freeze
+
+      sig { override.params(hook_ctx: BeforeRequestHookContext, request: Faraday::Request).returns(Faraday::Request) }
+      def before_request(hook_ctx:, request:)
+        if OPERATIONS.include?(hook_ctx.operation_id) && !request.headers.key?('Idempotency-Key')
+          request.headers['Idempotency-Key'] = SecureRandom.uuid
+        end
+        request
+      end
+    end
+  end
+end

data/lib/no_response/sdk_hooks/registration.rb

@@ -0,0 +1,43 @@
+# typed: true
+# frozen_string_literal: true
+
+#
+# This file is only ever generated once on the first generation and then is free to be modified.
+# Any hooks you wish to add should be registered in the init_hooks method.
+#
+# Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance.
+#
+
+require_relative "./types"
+# Hand-written helpers beside the generated client, loaded with the gem.
+require_relative "../webhooks"
+require_relative "../wait"
+require_relative "../late_results"
+require_relative "idempotency_key_hook"
+require_relative "../models/errors/apistatuserror"
+require_relative "../auth"
+require_relative "../issued_credential"
+
+module NoResponse
+  module SDKHooks
+    class Registration
+      extend T::Sig
+
+      sig do
+        params(
+          hooks: Hooks
+        )
+          .void
+      end
+      def self.init_hooks(hooks)
+        hooks.register_before_request_hook(IdempotencyKeyHook.new)
+        # example_hook = ExampleHook.new
+
+        # hooks.register_sdk_init_hook example_hook
+        # hooks.register_before_request_hook example_hook
+        # hooks.register_after_error_hook example_hook
+        # hooks.register_after_success_hook example_hook
+      end
+    end
+  end
+end

data/lib/no_response/sdk_hooks/types.rb

@@ -0,0 +1,178 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../sdkconfiguration"
+
+module NoResponse
+  module SDKHooks
+    class HookContext
+      extend T::Sig
+
+      sig { returns(SDKConfiguration) }
+      attr_accessor :config
+
+      sig { returns(String) }
+      attr_accessor :base_url
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :oauth2_scopes
+
+      sig { returns(String) }
+      attr_accessor :operation_id
+
+      sig { returns(T.nilable(T.proc.returns(T.untyped))) }
+      attr_accessor :security_source
+
+      sig do
+        params(
+          config: SDKConfiguration,
+          base_url: String,
+          oauth2_scopes: T.nilable(T::Array[String]),
+          operation_id: String,
+          security_source: T.nilable(T.proc.returns(T.untyped))
+        )
+          .void
+      end
+      def initialize(config:, base_url:, oauth2_scopes:, operation_id:, security_source:)
+        @config = T.let(config, SDKConfiguration)
+        @base_url = T.let(base_url, String)
+        @oauth2_scopes = T.let(oauth2_scopes, T.nilable(T::Array[String]))
+        @operation_id = T.let(operation_id, String)
+        @security_source = T.let(security_source, T.nilable(T.proc.returns(T.untyped)))
+      end
+    end
+
+    class BeforeRequestHookContext < HookContext
+      extend T::Sig
+
+      sig do
+        params(
+          hook_ctx: HookContext
+        )
+          .void
+      end
+      def initialize(hook_ctx:)
+        super(
+          config: hook_ctx.config,
+          base_url: hook_ctx.base_url,
+          operation_id: hook_ctx.operation_id,
+          oauth2_scopes: hook_ctx.oauth2_scopes,
+          security_source: hook_ctx.security_source
+        )
+      end
+    end
+
+    class AfterSuccessHookContext < HookContext
+      extend T::Sig
+
+      sig do
+        params(
+          hook_ctx: HookContext
+        )
+          .void
+      end
+      def initialize(hook_ctx:)
+        super(
+          config: hook_ctx.config,
+          base_url: hook_ctx.base_url,
+          operation_id: hook_ctx.operation_id,
+          oauth2_scopes: hook_ctx.oauth2_scopes,
+          security_source: hook_ctx.security_source
+        )
+      end
+    end
+
+    class AfterErrorHookContext < HookContext
+      extend T::Sig
+
+      sig do
+        params(
+          hook_ctx: HookContext
+        )
+          .void
+      end
+      def initialize(hook_ctx:)
+        super(
+          config: hook_ctx.config,
+          base_url: hook_ctx.base_url,
+          operation_id: hook_ctx.operation_id,
+          oauth2_scopes: hook_ctx.oauth2_scopes,
+          security_source: hook_ctx.security_source
+        )
+      end
+    end
+
+    module AbstractSDKInitHook
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig { overridable.params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
+        Kernel.raise NotImplementedError.new
+      end
+    end
+
+    module AbstractBeforeRequestHook
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig do
+        overridable
+          .params(
+            hook_ctx: BeforeRequestHookContext,
+            request: Faraday::Request
+          )
+          .returns(Faraday::Request)
+      end
+      def before_request(hook_ctx:, request:)
+        Kernel.raise NotImplementedError.new
+      end
+    end
+
+    module AbstractAfterSuccessHook
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig do
+        overridable
+          .params(
+            hook_ctx: AfterSuccessHookContext,
+            response: Faraday::Response
+          )
+          .returns(Faraday::Response)
+      end
+      def after_success(hook_ctx:, response:)
+        Kernel.raise NotImplementedError.new
+      end
+    end
+
+    module AbstractAfterErrorHook
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig do
+        overridable
+          .params(
+            error: T.nilable(StandardError),
+            hook_ctx: AfterErrorHookContext,
+            response: T.nilable(Faraday::Response)
+          )
+          .returns(T.nilable(Faraday::Response))
+      end
+      def after_error(error:, hook_ctx:, response:)
+        Kernel.raise NotImplementedError.new
+      end
+    end
+
+    class AbstractSDKHook
+      include AbstractSDKInitHook
+      include AbstractBeforeRequestHook
+      include AbstractAfterSuccessHook
+      include AbstractAfterErrorHook
+    end
+  end
+end

data/lib/no_response/sdkconfiguration.rb

@@ -0,0 +1,107 @@
+# typed: true
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "faraday/retry"
+require "sorbet-runtime"
+
+require_relative "sdk_hooks/hooks"
+require_relative "utils/retries"
+
+module NoResponse
+  extend T::Sig
+
+  SERVERS = T.let(
+    [
+      # 1 - Production
+      "https://api.noresponse.org"
+    ].freeze,
+    T::Array[String]
+  )
+  # Contains the list of servers available to the SDK
+
+  class SDKConfiguration
+    extend T::Sig
+
+    sig { returns(T.nilable(Faraday::Connection)) }
+    attr_accessor :client
+
+    sig { returns(::NoResponse::SDKHooks::Hooks) }
+    attr_accessor :hooks
+
+    sig { returns(T.nilable(::NoResponse::Utils::RetryConfig)) }
+    attr_accessor :retry_config
+
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    sig { returns(T.nilable(T.proc.returns(T.nilable(Models::Shared::Security)))) }
+    attr_accessor :security_source
+
+    sig { returns(T.nilable(String)) }
+    attr_accessor :server_url
+
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :server_idx
+
+    sig { returns(String) }
+    attr_accessor :language
+
+    sig { returns(String) }
+    attr_accessor :openapi_doc_version
+
+    sig { returns(String) }
+    attr_accessor :sdk_version
+
+    sig { returns(String) }
+    attr_accessor :gen_version
+
+    sig { returns(String) }
+    attr_accessor :user_agent
+
+    sig do
+      params(
+        client: T.nilable(Faraday::Connection),
+        hooks: ::NoResponse::SDKHooks::Hooks,
+        retry_config: T.nilable(::NoResponse::Utils::RetryConfig),
+        timeout_ms: T.nilable(Integer),
+        api_key: T.nilable(::String),
+        security_source: T.nilable(T.proc.returns(Models::Shared::Security)),
+        server_url: T.nilable(String),
+        server_idx: T.nilable(Integer)
+      )
+        .void
+    end
+    def initialize(client, hooks, retry_config, timeout_ms, api_key, security_source, server_url, server_idx)
+      @client = client
+      @hooks = hooks
+      @retry_config = retry_config
+      @server_url = server_url
+      @timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      @server_idx = server_idx.nil? ? 0 : server_idx
+      if @server_idx.negative? || @server_idx >= SERVERS.length
+        raise StandardError, "Invalid server index #{server_idx}"
+      end
+
+      if !security_source.nil?
+        @security_source = security_source
+      elsif !api_key.nil?
+        @security_source = -> { Models::Shared::Security.new(api_key: api_key) }
+      end
+
+      @language = "ruby"
+      @openapi_doc_version = "1"
+      @sdk_version = "2.0.17"
+      @gen_version = "internal"
+      @user_agent = "noresponse-sdk/ruby 2.0.17 internal 1 noresponse"
+    end
+
+    sig { returns([String, T::Hash[Symbol, String]]) }
+    def get_server_details
+      return [@server_url.delete_suffix("/"), {}] if !@server_url.nil?
+      @server_idx = T.must(@server_idx)
+      [T.must(SERVERS[@server_idx]), {}]
+    end
+  end
+end

data/lib/no_response/sdkconfiguration.rbi

@@ -0,0 +1,83 @@
+# typed: true
+
+class NoResponse::SDKConfiguration
+  extend ::Crystalline::MetadataFields::ClassMethods
+
+  def client
+  end
+
+  def client=(client)
+  end
+
+  def gen_version
+  end
+
+  def gen_version=(gen_version)
+  end
+
+  def hooks
+  end
+
+  def hooks=(hooks)
+  end
+
+  def language
+  end
+
+  def language=(language)
+  end
+
+  def openapi_doc_version
+  end
+
+  def openapi_doc_version=(openapi_doc_version)
+  end
+
+  def retry_config
+  end
+
+  def retry_config=(retry_config)
+  end
+
+  def sdk_version
+  end
+
+  def sdk_version=(sdk_version)
+  end
+
+  def security_source
+  end
+
+  def security_source=(security_source)
+  end
+
+  def server_idx
+  end
+
+  def server_idx=(server_idx)
+  end
+
+  def server_params
+  end
+
+  def server_params=(server_params)
+  end
+
+  def server_url
+  end
+
+  def server_url=(server_url)
+  end
+
+  def timeout
+  end
+
+  def timeout=(timeout)
+  end
+
+  def user_agent
+  end
+
+  def user_agent=(user_agent)
+  end
+end