svix 1.60.1 → 1.61.1

data/lib/svix/svix.rb

@@ -1,57 +1,57 @@
 # frozen_string_literal: true
 
 module Svix
-    class SvixOptions
-        attr_accessor :debug
-        attr_accessor :server_url
+  class SvixOptions
+    attr_accessor :debug
+    attr_accessor :server_url
 
-        def initialize(debug = false, server_url = nil)
-            @debug=debug
-            @server_url=server_url
-        end
+    def initialize(debug = false, server_url = nil)
+      @debug = debug
+      @server_url = server_url
     end
-
-    class Client
-        attr_accessor :application
-        attr_accessor :authentication
-        attr_accessor :endpoint
-        attr_accessor :event_type
-        attr_accessor :integration
-        attr_accessor :message
-        attr_accessor :message_attempt
-
-        def initialize(auth_token, options = SvixOptions.new)
-
-            region = auth_token.split(".").last
-            if region == "us"
-                regional_url = "https://api.us.svix.com"
-            elsif region == "eu"
-                regional_url = "https://api.eu.svix.com"
-            elsif region == "in"
-                regional_url = "https://api.in.svix.com"
-            else
-                regional_url = "https://api.svix.com"
-            end
-
-            uri = URI(options.server_url || regional_url)
-
-            configuration = Configuration.new
-            configuration.debugging = options.debug
-            configuration.scheme = uri.scheme
-            configuration.host = uri.port ? "#{uri.host}:#{uri.port}" : uri.host
-            configuration.access_token = auth_token
-            configuration.server_index = nil
-
-            api_client = ApiClient.new(configuration)
-            api_client.user_agent = "svix-libs/#{VERSION}/ruby"
-
-            @application = ApplicationAPI.new(api_client)
-            @authentication = AuthenticationAPI.new(api_client)
-            @endpoint = EndpointAPI.new(api_client)
-            @event_type = EventTypeAPI.new(api_client)
-            @integration = IntegrationAPI.new(api_client)
-            @message = MessageAPI.new(api_client)
-            @message_attempt = MessageAttemptAPI.new(api_client)
-        end
+  end
+
+  class Client
+    attr_accessor :application
+    attr_accessor :authentication
+    attr_accessor :background_task
+    attr_accessor :endpoint
+    attr_accessor :environment
+    attr_accessor :event_type
+    attr_accessor :health
+    attr_accessor :integration
+    attr_accessor :message
+    attr_accessor :message_attempt
+    attr_accessor :operational_webhook_endpoint
+    attr_accessor :statistics
+
+    def initialize(auth_token, options = SvixOptions.new)
+      region = auth_token.split(".").last
+      if region == "us"
+        regional_url = "https://api.us.svix.com"
+      elsif region == "eu"
+        regional_url = "https://api.eu.svix.com"
+      elsif region == "in"
+        regional_url = "https://api.in.svix.com"
+      else
+        regional_url = "https://api.svix.com"
+      end
+
+      uri = URI(options.server_url || regional_url)
+      api_client = SvixHttpClient.new(auth_token, uri)
+
+      @application = Application.new(api_client)
+      @authentication = Authentication.new(api_client)
+      @background_task = BackgroundTask.new(api_client)
+      @endpoint = Endpoint.new(api_client)
+      @environment = Environment.new(api_client)
+      @event_type = EventType.new(api_client)
+      @health = Health.new(api_client)
+      @integration = Integration.new(api_client)
+      @message = Message.new(api_client)
+      @message_attempt = MessageAttempt.new(api_client)
+      @operational_webhook_endpoint = OperationalWebhookEndpoint.new(api_client)
+      @statistics = Statistics.new(api_client)
     end
+  end
 end

data/lib/svix/svix_http_client.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require "uri"
+require "net/http"
+
+module Svix
+  class SvixHttpClient
+    def initialize(token, base_url)
+      @token = token
+      @base_url = base_url
+    end
+
+    def execute_request(method, path, **kwargs)
+      query_params = kwargs[:query_params] || {}
+      headers = kwargs[:headers] || {}
+      body = kwargs[:body] || {}
+
+      uri = URI("#{@base_url}#{path}")
+      encoded_query = encode_query_params(query_params)
+      if encoded_query != ""
+        uri.query = encoded_query
+      end
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+
+      # Dynamically select the request class based on method
+      request_class = case method.to_s.upcase
+      when "GET"
+        Net::HTTP::Get
+      when "POST"
+        Net::HTTP::Post
+      when "PUT"
+        Net::HTTP::Put
+      when "DELETE"
+        Net::HTTP::Delete
+      when "PATCH"
+        Net::HTTP::Patch
+      when "HEAD"
+        Net::HTTP::Head
+      else
+        raise ArgumentError, "Unsupported HTTP method: #{method}"
+      end
+
+      # Create request object
+      request = request_class.new(uri.request_uri)
+      request["Authorization"] = "Bearer #{@token}"
+      request["User-Agent"] = "svix-libs/#{VERSION}/ruby"
+      request["svix-req-id"] = rand(0...(2 ** 64))
+
+      # Add headers
+      headers.each { |key, value| request[key] = value }
+
+      # Add body for non-GET requests
+      if %w[POST PUT PATCH].include?(method.to_s.upcase) && !body.nil?
+        request.body = body.to_json
+        request["Content-Type"] = "application/json"
+      end
+
+      res = execute_request_with_retries(request, http)
+
+      # Execute request
+      if Integer(res.code) == 204
+        nil
+      elsif Integer(res.code) >= 200 && Integer(res.code) <= 299
+        JSON.parse(res.body)
+      else
+        fail(
+          ApiError.new(
+            :code => Integer(res.code),
+            :response_headers => res.each_header.to_h,
+            :response_body => res.body
+          )
+        )
+      end
+    end
+
+    private def execute_request_with_retries(request, http)
+      res = http.request(request)
+
+      [0.05, 0.1, 0.2].each_with_index do |sleep_duration, index|
+        unless Integer(res.code) >= 500
+          break
+        end
+
+        sleep(sleep_duration)
+        request["svix-retry-count"] = index + 1
+        res = http.request(request)
+      end
+
+      res
+    end
+
+    private def encode_query_params(query_params = {})
+      encoded_query_pairs = []
+      query_params.each do |k, v|
+        unless v.nil?
+          if v.kind_of?(Array)
+            encoded_query_pairs.append("#{k}=" + CGI::escape(v.sort.join(",")))
+          elsif v.kind_of?(Time)
+            encoded_query_pairs.append("#{k}=#{CGI::escape(v.utc.to_datetime.rfc3339)}")
+          else
+            encoded_query_pairs.append("#{k}=#{CGI::escape(v)}")
+          end
+        end
+      end
+
+      encoded_query_pairs.join("&")
+    end
+  end
+end

data/lib/svix/util.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "date"
 
 # Constant time string comparison, for fixed length strings.
 # Code borrowed from ActiveSupport
@@ -7,31 +8,49 @@
 # The values compared should be of fixed length, such as strings
 # that have already been processed by HMAC. Raises in case of length mismatch.
 module Svix
-    if defined?(OpenSSL.fixed_length_secure_compare)
-        def fixed_length_secure_compare(a, b)
-            OpenSSL.fixed_length_secure_compare(a, b)
-        end
-        else
-        def fixed_length_secure_compare(a, b)
-            raise ArgumentError, "string length mismatch." unless a.bytesize == b.bytesize
-
-            l = a.unpack "C#{a.bytesize}"
-
-            res = 0
-            b.each_byte { |byte| res |= byte ^ l.shift }
-            res == 0
-        end
+  if defined?(OpenSSL.fixed_length_secure_compare)
+    def fixed_length_secure_compare(a, b)
+      OpenSSL.fixed_length_secure_compare(a, b)
     end
-    module_function :fixed_length_secure_compare
-
-    # Secure string comparison for strings of variable length.
-    #
-    # While a timing attack would not be able to discern the content of
-    # a secret compared via secure_compare, it is possible to determine
-    # the secret length. This should be considered when using secure_compare
-    # to compare weak, short secrets to user input.
-    def secure_compare(a, b)
-        a.length == b.length && fixed_length_secure_compare(a, b)
+  else
+    def fixed_length_secure_compare(a, b)
+      raise ArgumentError, "string length mismatch." unless a.bytesize == b.bytesize
+
+      l = a.unpack("C#{a.bytesize}")
+
+      res = 0
+      b.each_byte { |byte| res |= byte ^ l.shift }
+      res == 0
+    end
+  end
+
+  module_function :fixed_length_secure_compare
+
+  # Secure string comparison for strings of variable length.
+  #
+  # While a timing attack would not be able to discern the content of
+  # a secret compared via secure_compare, it is possible to determine
+  # the secret length. This should be considered when using secure_compare
+  # to compare weak, short secrets to user input.
+  def secure_compare(a, b)
+    a.length == b.length && fixed_length_secure_compare(a, b)
+  end
+
+  module_function :secure_compare
+
+  def serialize_primitive(v)
+    if v.kind_of?(Time)
+      v.utc.to_datetime.rfc3339
+    else
+      v
     end
-    module_function :secure_compare
+  end
+
+  module_function :serialize_primitive
+
+  def deserialize_date(v)
+    DateTime.rfc3339(v)
+  end
+
+  module_function :deserialize_date
 end

data/lib/svix/validation_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Svix
+  # Validation errors have their own schema to provide context for invalid requests eg. mismatched types and out of bounds values. There may be any number of these per 422 UNPROCESSABLE ENTITY error.
+  class ValidationError
+    # The location as a [`Vec`] of [`String`]s -- often in the form `[\"body\", \"field_name\"]`, `[\"query\", \"field_name\"]`, etc. They may, however, be arbitrarily deep.
+    attr_accessor :loc
+
+    # The message accompanying the validation error item.
+    attr_accessor :msg
+
+    # The type of error, often \"type_error\" or \"value_error\", but sometimes with more context like as \"value_error.number.not_ge\"
+    attr_accessor :type
+
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `Svix::ValidationError` initialize method"
+        )
+      end
+
+      @loc = attributes[:"loc"]
+      @msg = attributes[:"msg"]
+      @type = attributes[:"type"]
+    end
+  end
+end

data/lib/svix/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Svix
-  VERSION = "1.60.1"
+  VERSION = "1.61.1"
 end

data/lib/svix/webhook.rb

@@ -1,79 +1,83 @@
 # frozen_string_literal: true
 
 module Svix
-    class Webhook
+  class Webhook
 
-        def self.new_using_raw_bytes(secret)
-            self.new(secret.pack("C*").force_encoding("UTF-8"))
-        end
+    def self.new_using_raw_bytes(secret)
+      self.new(secret.pack("C*").force_encoding("UTF-8"))
+    end
 
-        def initialize(secret)
-            if secret.start_with?(SECRET_PREFIX)
-                secret = secret[SECRET_PREFIX.length..-1]
-            end
+    def initialize(secret)
+      if secret.start_with?(SECRET_PREFIX)
+        secret = secret[SECRET_PREFIX.length..-1]
+      end
 
-            @secret = Base64.decode64(secret)
-        end
+      @secret = Base64.decode64(secret)
+    end
 
-        def verify(payload, headers)
-            msgId = headers["svix-id"]
-            msgSignature = headers["svix-signature"]
-            msgTimestamp = headers["svix-timestamp"]
-            if !msgSignature || !msgId || !msgTimestamp
-                msgId = headers["webhook-id"]
-                msgSignature = headers["webhook-signature"]
-                msgTimestamp = headers["webhook-timestamp"]
-                if !msgSignature || !msgId || !msgTimestamp
-                    raise WebhookVerificationError, "Missing required headers"
-                end
-            end
-
-            verify_timestamp(msgTimestamp)
-
-            _, signature = sign(msgId, msgTimestamp, payload).split(",", 2)
-
-            passedSignatures = msgSignature.split(" ")
-            passedSignatures.each do |versionedSignature|
-                version, expectedSignature = versionedSignature.split(",", 2)
-                if version != "v1"
-                    next
-                end
-                if ::Svix::secure_compare(signature, expectedSignature)
-                    return JSON.parse(payload, symbolize_names: true)
-                end
-            end
-            raise WebhookVerificationError, "No matching signature found"
+    def verify(payload, headers)
+      msgId = headers["svix-id"]
+      msgSignature = headers["svix-signature"]
+      msgTimestamp = headers["svix-timestamp"]
+      if !msgSignature || !msgId || !msgTimestamp
+        msgId = headers["webhook-id"]
+        msgSignature = headers["webhook-signature"]
+        msgTimestamp = headers["webhook-timestamp"]
+        if !msgSignature || !msgId || !msgTimestamp
+          raise WebhookVerificationError, "Missing required headers"
         end
+      end
 
-        def sign(msgId, timestamp, payload)
-            begin
-                now = Integer(timestamp)
-            rescue
-                raise WebhookSigningError, "Invalid timestamp"
-            end
-            toSign = "#{msgId}.#{timestamp}.#{payload}"
-            signature = Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new("sha256"), @secret, toSign)).strip
-            return "v1,#{signature}"
+      verify_timestamp(msgTimestamp)
+
+      _, signature = sign(msgId, msgTimestamp, payload).split(",", 2)
+
+      passedSignatures = msgSignature.split(" ")
+      passedSignatures.each do |versionedSignature|
+        version, expectedSignature = versionedSignature.split(",", 2)
+        if version != "v1"
+          next
         end
 
-        private
-        SECRET_PREFIX = "whsec_"
-        TOLERANCE = 5 * 60
-
-        def verify_timestamp(timestampHeader)
-            begin
-                now = Integer(Time.now)
-                timestamp = Integer(timestampHeader)
-            rescue
-                raise WebhookVerificationError, "Invalid Signature Headers"
-            end
-
-            if timestamp < (now - TOLERANCE)
-                raise WebhookVerificationError, "Message timestamp too old"
-            end
-            if timestamp > (now + TOLERANCE)
-                raise WebhookVerificationError, "Message timestamp too new"
-            end
+        if ::Svix::secure_compare(signature, expectedSignature)
+          return JSON.parse(payload, symbolize_names: true)
         end
+      end
+
+      raise WebhookVerificationError, "No matching signature found"
+    end
+
+    def sign(msgId, timestamp, payload)
+      begin
+        now = Integer(timestamp)
+      rescue
+        raise WebhookSigningError, "Invalid timestamp"
+      end
+
+      toSign = "#{msgId}.#{timestamp}.#{payload}"
+      signature = Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new("sha256"), @secret, toSign)).strip
+      return "v1,#{signature}"
+    end
+
+    private
+    SECRET_PREFIX = "whsec_"
+    TOLERANCE = 5 * 60
+
+    def verify_timestamp(timestampHeader)
+      begin
+        now = Integer(Time.now)
+        timestamp = Integer(timestampHeader)
+      rescue
+        raise WebhookVerificationError, "Invalid Signature Headers"
+      end
+
+      if timestamp < (now - TOLERANCE)
+        raise WebhookVerificationError, "Message timestamp too old"
+      end
+
+      if timestamp > (now + TOLERANCE)
+        raise WebhookVerificationError, "Message timestamp too new"
+      end
     end
+  end
 end

data/lib/svix.rb

@@ -1,97 +1,120 @@
 # frozen_string_literal: true
+# This file is @generated
 
 require "json"
 require "openssl"
 require "base64"
 require "uri"
+require "logger"
 
 # API
-require "svix/api/application_api"
-require "svix/api/authentication_api"
-require "svix/api/endpoint_api"
-require "svix/api/event_type_api"
-require "svix/api/health_api"
-require "svix/api/integration_api"
-require "svix/api/message_api"
-require "svix/api/message_attempt_api"
+require "svix/api/application"
+require "svix/api/authentication"
+require "svix/api/background_task"
+require "svix/api/endpoint"
+require "svix/api/environment"
+require "svix/api/event_type"
+require "svix/api/health"
+require "svix/api/ingest_endpoint"
+require "svix/api/integration"
+require "svix/api/message"
+require "svix/api/message_attempt"
+require "svix/api/operational_webhook_endpoint"
+require "svix/api/statistics"
 
 # Models
+require "svix/models/aggregate_event_types_out"
 require "svix/models/app_portal_access_in"
 require "svix/models/app_portal_access_out"
+require "svix/models/app_usage_stats_in"
+require "svix/models/app_usage_stats_out"
 require "svix/models/application_in"
 require "svix/models/application_out"
 require "svix/models/application_patch"
+require "svix/models/application_token_expire_in"
+require "svix/models/background_task_out"
+require "svix/models/background_task_status"
+require "svix/models/background_task_type"
+require "svix/models/connector_in"
+require "svix/models/connector_kind"
 require "svix/models/dashboard_access_out"
-require "svix/models/endpoint_created_event_data"
-require "svix/models/endpoint_created_event"
-require "svix/models/endpoint_deleted_event_data"
-require "svix/models/endpoint_deleted_event"
-require "svix/models/endpoint_disabled_event_data"
-require "svix/models/endpoint_disabled_event"
 require "svix/models/endpoint_headers_in"
 require "svix/models/endpoint_headers_out"
+require "svix/models/endpoint_headers_patch_in"
 require "svix/models/endpoint_in"
 require "svix/models/endpoint_message_out"
 require "svix/models/endpoint_out"
+require "svix/models/endpoint_patch"
 require "svix/models/endpoint_secret_out"
 require "svix/models/endpoint_secret_rotate_in"
+require "svix/models/endpoint_stats"
+require "svix/models/endpoint_transformation_in"
+require "svix/models/endpoint_transformation_out"
 require "svix/models/endpoint_update"
-require "svix/models/endpoint_updated_event_data"
-require "svix/models/endpoint_updated_event"
-require "svix/models/endpoint_patch"
+require "svix/models/environment_in"
+require "svix/models/environment_out"
 require "svix/models/event_example_in"
+require "svix/models/event_type_from_open_api"
 require "svix/models/event_type_import_open_api_in"
 require "svix/models/event_type_import_open_api_out"
 require "svix/models/event_type_import_open_api_out_data"
 require "svix/models/event_type_in"
 require "svix/models/event_type_out"
-require "svix/models/event_type_update"
 require "svix/models/event_type_patch"
-require "svix/models/http_error_out"
-require "svix/models/http_validation_error"
+require "svix/models/event_type_update"
+require "svix/models/expunge_all_contents_out"
+require "svix/models/ingest_endpoint_headers_in"
+require "svix/models/ingest_endpoint_headers_out"
+require "svix/models/ingest_endpoint_in"
+require "svix/models/ingest_endpoint_out"
+require "svix/models/ingest_endpoint_secret_in"
+require "svix/models/ingest_endpoint_secret_out"
+require "svix/models/ingest_endpoint_update"
 require "svix/models/integration_in"
 require "svix/models/integration_key_out"
 require "svix/models/integration_out"
 require "svix/models/integration_update"
 require "svix/models/list_response_application_out"
+require "svix/models/list_response_background_task_out"
 require "svix/models/list_response_endpoint_message_out"
 require "svix/models/list_response_endpoint_out"
 require "svix/models/list_response_event_type_out"
+require "svix/models/list_response_ingest_endpoint_out"
 require "svix/models/list_response_integration_out"
-require "svix/models/list_response_message_attempt_endpoint_out"
 require "svix/models/list_response_message_attempt_out"
 require "svix/models/list_response_message_endpoint_out"
 require "svix/models/list_response_message_out"
-require "svix/models/message_attempt_endpoint_out"
-require "svix/models/message_attempt_exhausted_event_data"
-require "svix/models/message_attempt_exhausted_event"
-require "svix/models/message_attempt_failing_event_data"
-require "svix/models/message_attempt_failing_event"
-require "svix/models/message_attempt_failed_data"
+require "svix/models/list_response_operational_webhook_endpoint_out"
 require "svix/models/message_attempt_out"
 require "svix/models/message_attempt_trigger_type"
 require "svix/models/message_endpoint_out"
 require "svix/models/message_in"
 require "svix/models/message_out"
 require "svix/models/message_status"
+require "svix/models/operational_webhook_endpoint_headers_in"
+require "svix/models/operational_webhook_endpoint_headers_out"
+require "svix/models/operational_webhook_endpoint_in"
+require "svix/models/operational_webhook_endpoint_out"
+require "svix/models/operational_webhook_endpoint_secret_in"
+require "svix/models/operational_webhook_endpoint_secret_out"
+require "svix/models/operational_webhook_endpoint_update"
+require "svix/models/ordering"
 require "svix/models/recover_in"
-require "svix/models/validation_error"
+require "svix/models/recover_out"
+require "svix/models/replay_in"
+require "svix/models/replay_out"
 require "svix/models/status_code_class"
+require "svix/models/template_out"
 
 # Core
-require "svix/api_client"
 require "svix/api_error"
-require "svix/application_api"
-require "svix/authentication_api"
-require "svix/configuration"
-require "svix/endpoint_api"
 require "svix/errors"
-require "svix/event_type_api"
-require "svix/integration_api"
-require "svix/message_api"
-require "svix/message_attempt_api"
 require "svix/svix"
 require "svix/util"
 require "svix/version"
 require "svix/webhook"
+require "svix/http_error_out"
+require "svix/http_validation_error"
+require "svix/validation_error"
+require "svix/svix_http_client.rb"
 require "svix/internal"