hooksniff 0.3.0 → 1.1.0

data/lib/hooksniff/api/message_attempt.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module HookSniff
+  class MessageAttempt
+    def initialize(client)
+      @client = client
+    end
+
+    def list_by_msg(message_id, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/v1/webhooks/#{message_id}/attempts",
+        query_params: {
+          "limit" => options["limit"],
+          "offset" => options["offset"],
+          "status" => options["status"]
+        }
+      )
+      ListResponseMessageAttemptOut.deserialize(res)
+    end
+
+    def get(attempt_id)
+      res = @client.execute_request("GET", "/v1/webhooks/attempts/#{attempt_id}")
+      MessageAttemptOut.deserialize(res)
+    end
+
+    def resend(message_id, endpoint_id)
+      res = @client.execute_request(
+        "POST",
+        "/v1/webhooks/#{message_id}/attempts/#{endpoint_id}/resend"
+      )
+      nil
+    end
+  end
+end

data/lib/hooksniff/api/statistics.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module HookSniff
+  class Statistics
+    def initialize(client)
+      @client = client
+    end
+
+    def aggregate_event_types(options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/v1/stats/event-types",
+        query_params: {
+          "since" => options["since"],
+          "until" => options["until"]
+        }
+      )
+      AggregateEventTypesOut.deserialize(res)
+    end
+
+    def app_stats(app_id, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/v1/stats/app/#{app_id}",
+        query_params: {
+          "since" => options["since"],
+          "until" => options["until"]
+        }
+      )
+      res
+    end
+  end
+end

data/lib/hooksniff/api/stream.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class StreamApi
+    def initialize(client)
+      @client = client
+    end
+
+    def list_channels
+      @client.request(:get, "/api/v1/stream/channels")
+    end
+
+    def get_channel(id)
+      @client.request(:get, "/api/v1/stream/channels/#{id}")
+    end
+
+    def create_channel(attrs)
+      @client.request(:post, "/api/v1/stream/channels", attrs)
+    end
+
+    def update_channel(id, attrs)
+      @client.request(:put, "/api/v1/stream/channels/#{id}", attrs)
+    end
+
+    def delete_channel(id)
+      @client.request(:delete, "/api/v1/stream/channels/#{id}")
+    end
+
+    def list_messages(id, params = {})
+      @client.request(:get, "/api/v1/stream/channels/#{id}/messages", params)
+    end
+
+    def list_subscriptions
+      @client.request(:get, "/api/v1/stream/subscriptions")
+    end
+
+    def disconnect_subscription(id)
+      @client.request(:delete, "/api/v1/stream/subscriptions/#{id}")
+    end
+
+    def publish(body)
+      @client.request(:post, "/api/v1/stream/publish", body)
+    end
+  end
+end

data/lib/{openapi_client → hooksniff}/api_error.rb

@@ -1,16 +1,6 @@
-=begin
-#HookSniff API
+# frozen_string_literal: true
 
-#Webhook delivery, monitoring, and management API. All endpoints under `/v1` require authentication via `Authorization: Bearer <api_key>` header unless marked as **Public**. 
-
-The version of the OpenAPI document: 1.0.0
-Contact: support@hooksniff.vercel.app
-Generated by: https://openapi-generator.tech
-Generator version: 7.22.0
-
-=end
-
-module OpenapiClient
+module HookSniff
   class ApiError < StandardError
     attr_reader :code, :response_headers, :response_body
 
@@ -20,18 +10,18 @@ module OpenapiClient
     #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
     #   ApiError.new(:code => 404, :message => "Not Found")
     def initialize(arg = nil)
-      if arg.is_a? Hash
-        if arg.key?(:message) || arg.key?('message')
-          super(arg[:message] || arg['message'])
+      if arg.is_a?(Hash)
+        if arg.key?(:message) || arg.key?("message")
+          super(arg[:message] || arg["message"])
         else
-          super arg
+          super(arg)
         end
 
         arg.each do |k, v|
-          instance_variable_set "@#{k}", v
+          instance_variable_set("@#{k}", v)
         end
       else
-        super arg
+        super(arg)
         @message = arg
       end
     end

data/lib/hooksniff/background_task.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class BackgroundTask
+    def initialize(api_client)
+      @api_client = api_client
+    end
+
+    def list
+      @api_client.execute(method: :get, path: "/api/v1/background-tasks")
+    end
+
+    def get(task_id)
+      @api_client.execute(method: :get, path: "/api/v1/background-tasks/#{task_id}")
+    end
+
+    def cancel(task_id)
+      @api_client.execute(method: :put, path: "/api/v1/background-tasks/#{task_id}")
+    end
+  end
+end

data/lib/hooksniff/connector.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Connector
+    def initialize(client)
+      @client = client
+    end
+
+    def list
+      @client.request(:get, "/api/v1/connectors")
+    end
+
+    def get(id)
+      @client.request(:get, "/api/v1/connectors/#{id}")
+    end
+
+    def list_configs
+      @client.request(:get, "/api/v1/connectors/configs")
+    end
+
+    def create_config(body)
+      @client.request(:post, "/api/v1/connectors/configs", body: body)
+    end
+
+    def update_config(id, body)
+      @client.request(:put, "/api/v1/connectors/configs/#{id}", body: body)
+    end
+
+    def delete_config(id)
+      @client.request(:delete, "/api/v1/connectors/configs/#{id}")
+    end
+  end
+end

data/lib/hooksniff/environment.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Environment
+    def initialize(api_client)
+      @api_client = api_client
+    end
+
+    def list
+      @api_client.execute(method: :get, path: "/api/v1/environments")
+    end
+
+    def create(environment_in)
+      @api_client.execute(method: :post, path: "/api/v1/environments", body: environment_in)
+    end
+
+    def get(environment_id)
+      @api_client.execute(method: :get, path: "/api/v1/environments/#{environment_id}")
+    end
+
+    def update(environment_id, environment_patch)
+      @api_client.execute(method: :put, path: "/api/v1/environments/#{environment_id}", body: environment_patch)
+    end
+
+    def delete(environment_id)
+      @api_client.execute(method: :delete, path: "/api/v1/environments/#{environment_id}")
+    end
+
+    def list_variables(environment_id)
+      @api_client.execute(method: :get, path: "/api/v1/environments/#{environment_id}/variables")
+    end
+
+    def get_variable(environment_id, variable_id)
+      @api_client.execute(method: :get, path: "/api/v1/environments/#{environment_id}/variables/#{variable_id}")
+    end
+
+    def create_variable(environment_id, variable_in)
+      @api_client.execute(method: :post, path: "/api/v1/environments/#{environment_id}/variables", body: variable_in)
+    end
+
+    def update_variable(environment_id, variable_id, variable_in)
+      @api_client.execute(method: :put, path: "/api/v1/environments/#{environment_id}/variables/#{variable_id}", body: variable_in)
+    end
+
+    def delete_variable(environment_id, variable_id)
+      @api_client.execute(method: :delete, path: "/api/v1/environments/#{environment_id}/variables/#{variable_id}")
+    end
+
+    def bulk_upsert_variables(environment_id, bulk_in)
+      @api_client.execute(method: :post, path: "/api/v1/environments/#{environment_id}/variables/bulk", body: bulk_in)
+    end
+  end
+end

data/lib/hooksniff/errors.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module HookSniff
+  # Base error class for all HookSniff API errors
+  class ApiError < StandardError
+    attr_reader :code, :response_headers, :response_body
+
+    def initialize(code:, response_headers: {}, response_body: nil)
+      @code = code
+      @response_headers = response_headers
+      @response_body = response_body
+      super("HookSniff API error #{code}")
+    end
+  end
+
+  # 400 Bad Request
+  class BadRequestError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 400, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 401 Unauthorized
+  class UnauthorizedError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 401, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 403 Forbidden
+  class ForbiddenError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 403, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 404 Not Found
+  class NotFoundError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 404, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 409 Conflict
+  class ConflictError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 409, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 422 Unprocessable Entity
+  class UnprocessableEntityError < ApiError
+    attr_reader :validation_errors
+
+    def initialize(validation_errors: [], response_headers: {}, response_body: nil)
+      super(code: 422, response_headers: response_headers, response_body: response_body)
+      @validation_errors = validation_errors
+    end
+  end
+
+  # 429 Rate Limited
+  class RateLimitError < ApiError
+    attr_reader :retry_after
+
+    def initialize(retry_after: nil, response_headers: {}, response_body: nil)
+      super(code: 429, response_headers: response_headers, response_body: response_body)
+      @retry_after = retry_after
+    end
+  end
+
+  # 500 Internal Server Error
+  class InternalServerError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 500, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 502 Bad Gateway
+  class BadGatewayError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 502, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 503 Service Unavailable
+  class ServiceUnavailableError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 503, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 504 Gateway Timeout
+  class GatewayTimeoutError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 504, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # Create the appropriate error from a status code
+  def self.create_error_from_status(status_code, response_headers: {}, response_body: nil)
+    case status_code
+    when 400
+      BadRequestError.new(response_headers: response_headers, response_body: response_body)
+    when 401
+      UnauthorizedError.new(response_headers: response_headers, response_body: response_body)
+    when 403
+      ForbiddenError.new(response_headers: response_headers, response_body: response_body)
+    when 404
+      NotFoundError.new(response_headers: response_headers, response_body: response_body)
+    when 409
+      ConflictError.new(response_headers: response_headers, response_body: response_body)
+    when 422
+      UnprocessableEntityError.new(response_headers: response_headers, response_body: response_body)
+    when 429
+      retry_after = response_headers["retry-after"]&.to_i
+      RateLimitError.new(retry_after: retry_after, response_headers: response_headers, response_body: response_body)
+    when 500
+      InternalServerError.new(response_headers: response_headers, response_body: response_body)
+    when 502
+      BadGatewayError.new(response_headers: response_headers, response_body: response_body)
+    when 503
+      ServiceUnavailableError.new(response_headers: response_headers, response_body: response_body)
+    when 504
+      GatewayTimeoutError.new(response_headers: response_headers, response_body: response_body)
+    else
+      ApiError.new(code: status_code, response_headers: response_headers, response_body: response_body)
+    end
+  end
+end

data/lib/hooksniff/hooksniff.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class HookSniffOptions
+    attr_accessor :debug
+    attr_accessor :server_url
+
+    def initialize(debug = false, server_url = nil)
+      @debug = debug
+      @server_url = server_url
+    end
+  end
+
+  class Client
+    attr_accessor :authentication
+    attr_accessor :endpoint
+    attr_accessor :event_type
+    attr_accessor :health
+    attr_accessor :message
+    attr_accessor :message_attempt
+    attr_accessor :statistics
+    attr_accessor :environment
+    attr_accessor :background_task
+    attr_accessor :operational_webhook
+    attr_accessor :message_poller
+    attr_accessor :inbound
+    attr_accessor :connector
+    attr_accessor :integration
+    attr_accessor :stream
+
+    def initialize(auth_token, options = HookSniffOptions.new)
+      uri = URI(options.server_url || "https://hooksniff-api-1046140057667.europe-west1.run.app")
+      api_client = HookSniffHttpClient.new(auth_token, uri)
+
+      @authentication = Authentication.new(api_client)
+      @endpoint = Endpoint.new(api_client)
+      @event_type = EventType.new(api_client)
+      @health = Health.new(api_client)
+      @message = Message.new(api_client)
+      @message_attempt = MessageAttempt.new(api_client)
+      @statistics = Statistics.new(api_client)
+      @environment = Environment.new(api_client)
+      @background_task = BackgroundTask.new(api_client)
+      @operational_webhook = OperationalWebhook.new(api_client)
+      @message_poller = MessagePoller.new(api_client)
+      @inbound = Inbound.new(api_client)
+      @connector = Connector.new(api_client)
+      @integration = IntegrationApi.new(api_client)
+      @stream = StreamApi.new(api_client)
+    end
+  end
+end

data/lib/hooksniff/hooksniff_http_client.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+require "cgi"
+require "uri"
+require "net/http"
+require "securerandom"
+
+
+module HookSniff
+  class HookSniffHttpClient
+    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"] = "hooksniff-libs/#{VERSION}/ruby"
+      request["hooksniff-req-id"] = rand(0...(2 ** 64))
+
+      # Add headers
+      headers.each { |key, value| request[key] = value }
+
+      # Check if idempotency-key header already exists
+      if !request.key?("idempotency-key") && method.to_s.upcase == "POST"
+        request["idempotency-key"] = "auto_" + SecureRandom.uuid.to_s
+      end
+
+      # 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|
+        # 429 Rate Limit — respect Retry-After header
+        if Integer(res.code) == 429
+          retry_after = res["Retry-After"]
+          delay = retry_after ? retry_after.to_f : sleep_duration
+          sleep(delay)
+          request["hooksniff-retry-count"] = index + 1
+          res = http.request(request)
+          next
+        end
+
+        unless Integer(res.code) >= 500
+          break
+        end
+
+        sleep(sleep_duration)
+        request["hooksniff-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/hooksniff/http_error_out.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class HttpErrorOut
+    attr_accessor :code
+
+    attr_accessor :detail
+
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `HookSniff::HttpErrorOut` initialize method")
+      end
+
+      @detail = attributes[:"detail"]
+      @code = attributes[:"code"]
+    end
+  end
+end

data/lib/hooksniff/http_validation_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class HTTPValidationError
+    attr_accessor :detail
+
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `HookSniff::HTTPValidationError` initialize method"
+        )
+      end
+
+      @detail = attributes[:"detail"]
+    end
+  end
+end

data/lib/hooksniff/inbound.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Inbound
+    def initialize(client)
+      @client = client
+    end
+
+    def list_configs
+      @client.request(:get, "/api/v1/inbound/configs")
+    end
+
+    def create_config(body)
+      @client.request(:post, "/api/v1/inbound/configs", body: body)
+    end
+
+    def update_config(id, body)
+      @client.request(:put, "/api/v1/inbound/configs/#{id}", body: body)
+    end
+
+    def delete_config(id)
+      @client.request(:delete, "/api/v1/inbound/configs/#{id}")
+    end
+  end
+end

data/lib/hooksniff/internal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module HookSniff
+  private_constant :HttpErrorOut
+  private_constant :HTTPValidationError
+  private_constant :ValidationError
+end

data/lib/hooksniff/message_poller.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class MessagePoller
+    def initialize(client)
+      @client = client
+    end
+
+    # Poll for new messages since the consumer's cursor.
+    def poll(consumer_id, limit: nil, endpoint_id: nil, event_type: nil, include_payload: true)
+      params = { consumer_id: consumer_id, include_payload: include_payload }
+      params[:limit] = limit if limit
+      params[:endpoint_id] = endpoint_id if endpoint_id
+      params[:event_type] = event_type if event_type
+      @client.request(:get, "/api/v1/message-poller/poll", params: params)
+    end
+
+    # Seek cursor to a specific message.
+    def seek(consumer_id, message_id, endpoint_id: nil)
+      body = { consumer_id: consumer_id, message_id: message_id }
+      body[:endpoint_id] = endpoint_id if endpoint_id
+      @client.request(:post, "/api/v1/message-poller/seek", body: body)
+    end
+
+    # Commit cursor — advance past a processed message.
+    def commit(consumer_id, message_id, endpoint_id: nil)
+      body = { consumer_id: consumer_id, message_id: message_id }
+      body[:endpoint_id] = endpoint_id if endpoint_id
+      @client.request(:post, "/api/v1/message-poller/commit", body: body)
+    end
+  end
+end