noresponse 2.1.10 → 2.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa850a7e8b70f2991de9e114685af4f2a6820888e1f4fe805cdad030902e13c1
-  data.tar.gz: 94f598e386f9e942ef67b3dfd2e83ae104dc4dd2345785c48587f28c081c54ec
+  metadata.gz: '0887b8b6bdb2aa397a78ffc4e47ae7333b8690c5eae5d05414fed435d80388b9'
+  data.tar.gz: 961249318ae7beeece316675cff1890485e31c58c766fe1e1f458d55e8ba9c2c
 SHA512:
-  metadata.gz: bc83f0343b1474ad7d2264e02c6c95668dbf33d243f551d76df5d3bc439bc25705646771d49dafcec908d3b10162b224188ca6982c9e3ba97c7a7d88b9ad2746
-  data.tar.gz: c230e855babf8e941034ae409130a8a8942551a92f9c1595a7a49e4b5ddc8cdc6c08a0ca51831e808e78e6f3884defc28bf76ee486cfa6f85be9fb29229c3309
+  metadata.gz: 2c9cb2e25114a894e24648a86ee367024342793fb2dffbd0958b48715ec819753920565996415697c53fee7b4693878793ff8e03b70ca38dbd380a325496bd13
+  data.tar.gz: eaa811dab0c0386e73ed2403b4c3be013f93cb390274333a7cbed3c277891833df0bd8faad58df42743b0347c97269fdf210292f18f98f48d680a027e4a58c28

data/lib/no_response/accounts.rb

@@ -326,6 +326,294 @@ module NoResponse
       end
     end
 
+    sig {
+      params(
+        account_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::DeleteAccountResponse)
+    }
+    def delete(account_id:, retries: nil, timeout_ms: nil, http_headers: nil)
+      # delete - Erase an account and its history.
+      # Erases the account in the environment of your key, for an erasure request from your user: every assessment of it, with its revisions, evidence and outcomes, and the identity-graph marks its outcomes set. An assessment of the account begun before the call is refused or stopped. Afterwards the account and each erased assessment answer 404 and the history is empty. When the call deleted at least one assessment, an account.deleted event goes to your verified webhook endpoints. Requires the history scope. Idempotent and safe to retry: a repeat, or an account with nothing to erase, answers 200 with assessments_deleted 0 and sends no event. The account_id can be assessed again later, as a new account.
+      request = Models::Operations::DeleteAccountRequest.new(
+        account_id: account_id
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::DeleteAccountRequest,
+        base_url,
+        "/v1/accounts/{account_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: "deleteAccount",
+        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::AccountDeletion)
+          result = obj
+          response = Models::Operations::DeleteAccountResponse.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(
         account_id: ::String,

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

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class DeleteAccountRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The account_id the tenant sends with its assessments, as one path segment (percent-encode '|' and ':' if the client requires it). A value that does not match the account_id shape answers 400 invalid_request.
+        field :account_id, ::String, {'path_param': {'field_name': "account_id", 'style': "simple", 'explode': false}}
+
+        sig { params(account_id: ::String).void }
+        def initialize(account_id:)
+          @account_id = account_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @account_id == other.account_id
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class DeleteAccountResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
+
+        field :result, Models::Shared::AccountDeletion, {}
+
+        sig { params(headers: T::Hash[Symbol, T::Array[::String]], result: Models::Shared::AccountDeletion).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/deleteaccount_response.rbi

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

data/lib/no_response/models/operations.rb

@@ -8,6 +8,8 @@ module NoResponse
       autoload :CreateAssessmentResponse, "no_response/models/operations/createassessment_response.rb"
       autoload :CreateIntegrationResponse, "no_response/models/operations/createintegration_response.rb"
       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 :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/accountdeletion.rb

@@ -0,0 +1,78 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Body of the 200 answer to DELETE /v1/accounts/{account_id}: the calling tenant's account was erased in the environment of the calling key. Every assessment of the account went, with its revisions, evidence, outcomes and the identity-graph marks its outcomes set, and an assessment that was still running when the call arrived is stopped. Afterwards GET /v1/accounts/{account_id} and GET /v1/assessments/{assessment_id} of each erased assessment answer 404, and the history page is empty. The call is idempotent: a repeat, or an account with nothing to erase, answers 200 with assessments_deleted 0. The account_id can be assessed again later, as a new account.
+      class AccountDeletion
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The account_id that was erased.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # How many assessments this call deleted. 0 when the account had none left, so a repeat answers 0.
+        field(
+          :assessments_deleted,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("assessments_deleted"), required: true}}
+        )
+        # When the erasure took effect. An assessment of the account begun before this time is refused or stopped.
+        field(
+          :deleted_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("deleted_at"), required: true}}
+        )
+        # Version of the body shape.
+        field(
+          :schema_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
+        )
+
+        field(
+          :deleted,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("deleted"), required: true}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            assessments_deleted: ::Integer,
+            deleted_at: ::String,
+            schema_version: ::String,
+            deleted: T::Boolean
+          )
+            .void
+        }
+        def initialize(id:, assessments_deleted:, deleted_at:, schema_version: "1", deleted: true)
+          @id = id
+          @assessments_deleted = assessments_deleted
+          @deleted_at = deleted_at
+          unless schema_version == "1"
+            raise ArgumentError, "Invalid value for schema_version"
+          end
+
+          @schema_version = "1"
+          unless deleted == true
+            raise ArgumentError, "Invalid value for deleted"
+          end
+
+          @deleted = true
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @id == other.id
+          return false unless @assessments_deleted == other.assessments_deleted
+          return false unless @deleted_at == other.deleted_at
+          return false unless @schema_version == other.schema_version
+          return false unless @deleted == other.deleted
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/accountdeletion.rbi

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountDeletion
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountDeletion
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def assessments_deleted
+  end
+
+  def assessments_deleted=(str_)
+  end
+
+  def deleted_at
+  end
+
+  def deleted_at=(str_)
+  end
+
+  def schema_version
+  end
+
+  def schema_version=(str_)
+  end
+
+  def deleted
+  end
+
+  def deleted=(str_)
+  end
+end

data/lib/no_response/models/shared.rb

@@ -7,6 +7,7 @@ module NoResponse
       autoload :Account, "no_response/models/shared/account.rb"
       autoload :AccountDecision, "no_response/models/shared/accountdecision.rb"
       autoload :AccountDecisionsByFlow, "no_response/models/shared/accountdecisionsbyflow.rb"
+      autoload :AccountDeletion, "no_response/models/shared/accountdeletion.rb"
       autoload :AccountRisk, "no_response/models/shared/accountrisk.rb"
       autoload :AccountRiskReason, "no_response/models/shared/accountriskreason.rb"
       autoload :Assessment, "no_response/models/shared/assessment.rb"

data/lib/no_response/sdkconfiguration.rb

@@ -95,9 +95,9 @@ module NoResponse
 
       @language = "ruby"
       @openapi_doc_version = "1"
-      @sdk_version = "2.1.10"
+      @sdk_version = "2.1.12"
       @gen_version = "internal"
-      @user_agent = "noresponse-sdk/ruby 2.1.10 internal 1 noresponse"
+      @user_agent = "noresponse-sdk/ruby 2.1.12 internal 1 noresponse"
     end
 
     sig { returns([String, T::Hash[Symbol, String]]) }

data/lib/no_response/webhooks.rb

@@ -45,10 +45,16 @@ module NoResponse
 
     EndpointVerification = Struct.new(:endpoint_id, :challenge, keyword_init: true)
 
+    # An account you erased with accounts.delete: delete what you hold for it.
+    # assessments_deleted is at least 1, and deleted_at equals deleted_at in
+    # the delete answer.
+    AccountDeleted = Struct.new(:account_id, :assessments_deleted, :deleted_at, keyword_init: true)
+
     # A verified delivery. data is a Models::Shared::Assessment (exactly as
     # assessments.get returns it) or an AssessmentExpired for type
-    # "assessment.updated", and an EndpointVerification for
-    # "endpoint.verification". Deliveries are at least once and unordered:
+    # "assessment.updated", an EndpointVerification for
+    # "endpoint.verification" and an AccountDeleted for "account.deleted".
+    # Deliveries are at least once and unordered:
     # deduplicate on id and keep the highest assessment_version.
     Event = Struct.new(:id, :type, :created_at, :data, :test, keyword_init: true) do
       # True for the terminal expiry event: delete what you hold and fetch nothing.
@@ -155,6 +161,8 @@ module NoResponse
           rescue KeyError, TypeError, ArgumentError, NoMethodError
             raise VerificationError.new(:invalid_payload, 'Webhook data is not an assessment')
           end
+        when 'account.deleted'
+          account_deleted(data)
         else
           raise VerificationError.new(:invalid_payload, 'Unknown webhook event type')
         end
@@ -171,6 +179,17 @@ module NoResponse
                               assessment_version: data['assessment_version'])
       end
 
+      def account_deleted(data)
+        unless data['account_id'].is_a?(String) && ACCOUNT_ID.match?(data['account_id']) &&
+               data['assessments_deleted'].is_a?(Integer) && data['assessments_deleted'] >= 1 &&
+               data['deleted_at'].is_a?(String) && valid_datetime?(data['deleted_at'])
+          raise VerificationError.new(:invalid_payload, 'Account deleted event is malformed')
+        end
+
+        AccountDeleted.new(account_id: data['account_id'], assessments_deleted: data['assessments_deleted'],
+                           deleted_at: data['deleted_at'])
+      end
+
       def valid_datetime?(value)
         Time.iso8601(value)
         true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noresponse
 version: !ruby/object:Gem::Version
-  version: 2.1.10
+  version: 2.1.12
 platform: ruby
 authors:
 - NoResponse
@@ -284,6 +284,10 @@ files:
 - lib/no_response/models/operations/createintegration_response.rbi
 - lib/no_response/models/operations/createwebhookendpoint_response.rb
 - lib/no_response/models/operations/createwebhookendpoint_response.rbi
+- lib/no_response/models/operations/deleteaccount_request.rb
+- lib/no_response/models/operations/deleteaccount_request.rbi
+- lib/no_response/models/operations/deleteaccount_response.rb
+- lib/no_response/models/operations/deleteaccount_response.rbi
 - lib/no_response/models/operations/deleteintegration_request.rb
 - lib/no_response/models/operations/deleteintegration_request.rbi
 - lib/no_response/models/operations/deleteintegration_response.rb
@@ -343,6 +347,8 @@ files:
 - lib/no_response/models/shared/accountdecision.rbi
 - lib/no_response/models/shared/accountdecisionsbyflow.rb
 - lib/no_response/models/shared/accountdecisionsbyflow.rbi
+- lib/no_response/models/shared/accountdeletion.rb
+- lib/no_response/models/shared/accountdeletion.rbi
 - lib/no_response/models/shared/accountrisk.rb
 - lib/no_response/models/shared/accountrisk.rbi
 - lib/no_response/models/shared/accountriskreason.rb