noresponse 2.1.14 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9c7ea57323988c4c7426888734ef4c533166f83c713af0005ecfcb6d3a3ee43
-  data.tar.gz: f61a863f292e168cd2e6505479fb77346057088300d72f164b74a015647b0efc
+  metadata.gz: 9ba556406e80e6bb7f20aeee106cc215b9872a1fbd1816663d6da76af9c1d568
+  data.tar.gz: 3c1214f820469af0cdc955ad85c6526edb30144fdf937f4a41f896f47b0b84cc
 SHA512:
-  metadata.gz: bb0dc8a6a3469249db874f6fc187e8697b2ce7eb0b921231e6447be07578d6484ea9b302fa03b723be8219711bd2f53889ab3d2d95233bad9826bb6d43cfac6a
-  data.tar.gz: 8b7bc769f6a8c3c961c5180e3707a39896af75047491a480e70a744e2fd0931aeaa44062ce705e995b9229b1e2ef1d05d0891841ea4959fc21e5cd4a56e003b9
+  metadata.gz: 0023bb0cc6f1a40b655291291b9f06a478216cf395cde6e734497fbde1b3f304dac4e9fee9f9e9a9f2c779a013cf07b543bec5dbb27a09a90077a275cd763ff0
+  data.tar.gz: 79758d27c28ddf6630ac6e7e33db49011e4b19f56c1e272fe85d3d32f67a806f246d16dfa5a459121c1f69463d5a8cab4bdd31b2b3b0c70485caa0196db162dc

data/lib/no_response/accounts.rb

@@ -49,7 +49,7 @@ module NoResponse
     }
     def get(account_id:, retries: nil, timeout_ms: nil, http_headers: nil)
       # get - Read an account's one current risk.
-      # An account is the account_id you send with your assessments. Its current risk is the risk of its latest assessment with a decision (status complete or partial), scored as GET /v1/assessments/{assessment_id} scores that assessment, with a decision for each flow. Every assessment updates its account: once an assessment completes, the account carries its risk. Requires the history scope. Read-only and safe to retry. An account with no unexpired assessment that has a decision answers 404 not_found, and a malformed account_id answers 400 invalid_request.
+      # An account is the account_id you send with your assessments. Its current risk is the risk of its latest assessment with a decision (status complete or partial), scored as GET /v1/assessments/{assessment_id} scores that assessment, with a decision for each flow; risk.decision is the decision for the flow of that assessment. Every assessment answers with this same account. Every assessment updates its account: once an assessment completes, the account carries its risk. Requires the history scope. Read-only and safe to retry. An account with no unexpired assessment that has a decision answers 404 not_found, and a malformed account_id answers 400 invalid_request.
       request = Models::Operations::GetAccountRequest.new(
         account_id: account_id
       )

data/lib/no_response/assessments.rb

@@ -50,7 +50,7 @@ module NoResponse
     }
     def create(body:, idempotency_key: nil, retries: nil, timeout_ms: nil, http_headers: nil)
       # create - Assess identifiers for a signup or gateway decision.
-      # Returns within the deadline (3000 ms at most) with a complete, partial or pending assessment: 200 carries complete or partial, 202 carries pending with Location and Retry-After. A pending answer has no recommendation; apply your own fallback for pending, 429, 503 or a timeout. risk.block says when your block threshold was reached. Requires the assess scope. Idempotency-Key is optional in the SDK and is bound to the body for 24 hours: the same key with the same body replays the latest assessment with Idempotent-Replayed: true and starts no new work; the same key with a different body answers 409 idempotency_key_reused. response_mode defaults to standard; detailed needs the detailed scope.
+      # Assesses one signup, login or purchase (flow) and answers with the account's one current risk: account.risk.decision is the decision for this flow (allow, step_up, review or block, where block means your block threshold was reached), and detail holds this assessment's own facts. depth sets how long the answer waits for sources: quick waits only for the fast ones (500 ms), full for the whole budget (3000 ms at most); it defaults to full for signup and purchase and quick for login. 200 carries complete or partial, 202 carries pending with Location and Retry-After. While the account's first assessment is pending, account is absent: apply your own fallback for that, 429, 503 or a timeout. NoResponse blocks nothing itself; you decide. Requires the assess scope. Idempotency-Key is optional in the SDK and is bound to the body for 24 hours: the same key with the same body replays the latest assessment with Idempotent-Replayed: true and starts no new work; the same key with a different body answers 409 idempotency_key_reused. response_mode defaults to standard; detailed needs the detailed scope.
       request = Models::Operations::CreateAssessmentRequest.new(
         body: body,
         idempotency_key: idempotency_key
@@ -348,7 +348,7 @@ module NoResponse
     }
     def get(assessment_id:, response_mode: nil, retries: nil, timeout_ms: nil, http_headers: nil)
       # get - Poll the authoritative assessment of one assessment.
-      # Returns the highest assessment_version. Requires the assess or history scope. While status is pending, or partial with a source still running, the response carries Retry-After; poll no faster than it says. Another tenant's assessment, an unknown or expired assessment and a malformed assessment_id all answer 404 not_found. response_mode=detailed needs the detailed scope.
+      # Returns the highest assessment_version, with the account's current risk. Requires the assess or history scope. While status is pending, or partial with a source still running, the response carries Retry-After; poll no faster than it says. Another tenant's assessment, an unknown or expired assessment and a malformed assessment_id all answer 404 not_found. response_mode=detailed needs the detailed scope.
       request = Models::Operations::GetAssessmentRequest.new(
         assessment_id: assessment_id,
         response_mode: response_mode
@@ -628,6 +628,294 @@ module NoResponse
       end
     end
 
+    sig {
+      params(
+        assessment_id: ::String,
+        retries: T.nilable(Utils::RetryConfig),
+        timeout_ms: T.nilable(Integer),
+        http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])
+      )
+        .returns(Models::Operations::DeleteAssessmentResponse)
+    }
+    def delete(assessment_id:, retries: nil, timeout_ms: nil, http_headers: nil)
+      # delete - Delete one assessment.
+      # Deletes one assessment in the environment of your key, with its versions, evidence and outcomes and the identity-graph marks its outcomes set, and scores its account again from what remains. Afterwards the assessment answers 404 and leaves the account's history. The answer names the account and the assessment its current risk now comes from; current_assessment_id is absent when the account has no assessment with a decision left. Requires the history scope. An unknown, expired or already deleted assessment answers 404, so a repeat answers 404; to erase a whole account idempotently, use accounts.delete.
+      request = Models::Operations::DeleteAssessmentRequest.new(
+        assessment_id: assessment_id
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::DeleteAssessmentRequest,
+        base_url,
+        "/v1/assessments/{assessment_id}",
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      headers["Accept"] = "application/json"
+      headers["user-agent"] = @sdk_configuration.user_agent
+      retries ||= @sdk_configuration.retry_config
+      retries ||= Utils::RetryConfig.new(
+        backoff: Utils::BackoffStrategy.new(
+          exponent: 2.0,
+          initial_interval: 500,
+          max_elapsed_time: 30_000,
+          max_interval: 8000
+        ),
+        retry_connection_errors: true,
+        strategy: "backoff"
+      )
+      retry_options = retries.to_faraday_retry_options(initial_time: Time.now)
+      retry_options[:retry_statuses] = [408, 429, 500, 501, 502, 503, 504, 505]
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+      connection = @sdk_configuration.client.dup
+      connection.use(Utils::RetryMiddleware, retry_options)
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: "deleteAssessment",
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+
+      begin
+        http_response = T.must(connection).delete(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+
+        if http_response.nil?
+          raise error if !error.nil?
+          raise "no response"
+        end
+      end
+
+      content_type = http_response.headers.fetch("Content-Type", "application/octet-stream")
+      if Utils.match_status_code(http_response.status, ["200"])
+        if Utils.match_content_type(content_type, "application/json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AssessmentDeletion)
+          result = obj
+          response = Models::Operations::DeleteAssessmentResponse.new(
+            result: result,
+            headers: http_response.headers
+          )
+
+          return response
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["400"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadRequestError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["401"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::AuthenticationError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["403"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::PermissionDeniedError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["404"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::NotFoundError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["409"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ConflictError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["429"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::RateLimitError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["4XX"])
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      elsif Utils.match_status_code(http_response.status, ["5XX"])
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      else
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "Unknown status code received"
+        )
+
+      end
+    end
+
     sig {
       params(
         body: Models::Shared::AssessmentOutcomeRequest,

data/lib/no_response/late_results.rb

@@ -4,7 +4,7 @@
 # Late-result handlers. Hand-written beside the generated client.
 #
 # An assessment can be revised after the signup was allowed: a slow source
-# settles and the recommendation rises. NoResponse sends the new version as a
+# settles and the account's decision rises. NoResponse sends the new version as a
 # signed assessment.updated webhook. LateResults.handle verifies that delivery
 # with Webhooks.construct_event, picks an action from your policy, and acts
 # through the auth provider's admin API: revoke the user's sessions or ban the
@@ -30,10 +30,12 @@ module NoResponse
     BAN = 'ban'
     ACTIONS = [NONE, REVOKE_SESSIONS, BAN].freeze
 
-    # Revoke sessions on review; do nothing on allow or step_up. Banning is opt-in.
-    DEFAULT_POLICY = { 'allow' => NONE, 'step_up' => NONE, 'review' => REVOKE_SESSIONS }.freeze
+    # Revoke sessions on review and block; do nothing on allow or step_up.
+    # Banning is opt-in.
+    DEFAULT_POLICY = { 'allow' => NONE, 'step_up' => NONE, 'review' => REVOKE_SESSIONS,
+                       'block' => REVOKE_SESSIONS }.freeze
 
-    RECOMMENDATIONS = %w[allow step_up review].freeze
+    DECISIONS = %w[allow step_up review block].freeze
 
     # Raised when the provider's admin API refuses a call. Answer the webhook
     # with a 5xx so NoResponse retries it. The message holds no response body
@@ -61,23 +63,25 @@ module NoResponse
     Result = Struct.new(:event, :action, :user_id, keyword_init: true)
 
     class << self
-      # The action your policy names for a verified event. Only a served
-      # assessment with a recommendation can act; a test event never does.
-      # policy maps allow, step_up and review (as strings or symbols) to NONE,
-      # REVOKE_SESSIONS or BAN; a recommendation you leave out does nothing. An
-      # unknown action raises ArgumentError.
+      # The action your policy names for a verified event, from the account's
+      # decision (data.account.risk.decision). Only a served assessment whose
+      # account has a decision can act; a pending assessment, an expiry and a
+      # test event never do. policy maps allow, step_up, review and block (as
+      # strings or symbols) to NONE, REVOKE_SESSIONS or BAN; a decision you
+      # leave out does nothing. An unknown action raises ArgumentError.
       def action_for(event, policy = DEFAULT_POLICY)
         return NONE if event.type != 'assessment.updated' || event.test? || event.expired?
 
         data = event.data
-        recommendation = data.recommendation || data.risk&.recommendation
-        recommendation = recommendation.to_s
-        return NONE unless RECOMMENDATIONS.include?(recommendation)
+        return NONE if data.status == Models::Shared::Status::PENDING || data.account.nil?
+
+        decision = data.account.risk.decision.to_s
+        return NONE unless DECISIONS.include?(decision)
 
         table = policy.to_h.transform_keys(&:to_s)
-        return NONE unless table.key?(recommendation)
+        return NONE unless table.key?(decision)
 
-        action = table[recommendation]
+        action = table[decision]
         return NONE if action.nil?
 
         action = action.to_s
@@ -103,7 +107,7 @@ module NoResponse
         action = action_for(event, policy)
         return Result.new(event: event, action: NONE) if action == NONE || event.type != 'assessment.updated'
 
-        account_id = event.data.account_id
+        account_id = event.data.detail.account_id
         resolved = user_id ? user_id.call(account_id, event) : account_id
         return Result.new(event: event, action: NONE) if resolved.nil? || resolved.to_s.empty?
 

data/lib/no_response/models/operations/deleteassessment_request.rb

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class DeleteAssessmentRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Path segment, matched case-sensitively. A value that does not match the assessment_id shape answers 404, not 400.
+        field(
+          :assessment_id,
+          ::String,
+          {'path_param': {'field_name': "assessment_id", 'style': "simple", 'explode': false}}
+        )
+
+        sig { params(assessment_id: ::String).void }
+        def initialize(assessment_id:)
+          @assessment_id = assessment_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @assessment_id == other.assessment_id
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/deleteassessment_request.rbi

@@ -0,0 +1,14 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::DeleteAssessmentRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::DeleteAssessmentRequest
+  def assessment_id
+  end
+
+  def assessment_id=(str_)
+  end
+end

data/lib/no_response/models/operations/deleteassessment_response.rb

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class DeleteAssessmentResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
+
+        field :result, Models::Shared::AssessmentDeletion, {}
+
+        sig { params(headers: T::Hash[Symbol, T::Array[::String]], result: Models::Shared::AssessmentDeletion).void }
+        def initialize(headers:, result:)
+          @headers = headers
+          @result = result
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @headers == other.headers
+          return false unless @result == other.result
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/deleteassessment_response.rbi

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::DeleteAssessmentResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::DeleteAssessmentResponse
+  def headers
+  end
+
+  def headers=(str_)
+  end
+
+  def result
+  end
+
+  def result=(str_)
+  end
+end

data/lib/no_response/models/operations.rb

@@ -10,6 +10,8 @@ module NoResponse
       autoload :CreateWebhookEndpointResponse, "no_response/models/operations/createwebhookendpoint_response.rb"
       autoload :DeleteAccountRequest, "no_response/models/operations/deleteaccount_request.rb"
       autoload :DeleteAccountResponse, "no_response/models/operations/deleteaccount_response.rb"
+      autoload :DeleteAssessmentRequest, "no_response/models/operations/deleteassessment_request.rb"
+      autoload :DeleteAssessmentResponse, "no_response/models/operations/deleteassessment_response.rb"
       autoload :DeleteIntegrationRequest, "no_response/models/operations/deleteintegration_request.rb"
       autoload :DeleteIntegrationResponse, "no_response/models/operations/deleteintegration_response.rb"
       autoload :DeleteWebhookEndpointRequest, "no_response/models/operations/deletewebhookendpoint_request.rb"

data/lib/no_response/models/shared/account.rb

@@ -17,7 +17,7 @@ module NoResponse
           Models::Shared::AccountRisk,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("risk"), required: true}}
         )
-        # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three equal risk.decision.
+        # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three are equal.
         field(
           :decisions_by_flow,
           Models::Shared::AccountDecisionsByFlow,

data/lib/no_response/models/shared/accountdecisionsbyflow.rb

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-      # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three equal risk.decision.
+      # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three are equal.
       class AccountDecisionsByFlow
         extend T::Sig
         include Crystalline::MetadataFields