hooksniff 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97532c0ab6de4c3b1427b22a571a2637cb1d8c666b5d90c96a303ee43b100e8b
-  data.tar.gz: 40cf971ef0f0b0641621af647b3791a87821c894545eac6366ea4c05df888c84
+  metadata.gz: b5aaa88a65699339eb037c794a5d39c3cf2a7aecd9f51536c66f724ceb167e63
+  data.tar.gz: 8fc8649416effe14346d24ef9d9853f84b47f172f4e8521761f5a386b1017a47
 SHA512:
-  metadata.gz: 0fc3db5d623e798a34e9983930a97aa8a05dd319cf48004d34dc4fa5dfeee54d6c40a0350469950ba985cd77ee7e5d4ca4b11757d051540036db213e96920610
-  data.tar.gz: ca1157a3ec1a9384ad2a2fae4fe185f0b761f4946cbcbc0eef435ba9d410f9b3f2724046edaa6980970e583c72b7640d71e77c42f2f2f6ab72bc0e235dcc5b8c
+  metadata.gz: 28cf8842859a1b34b5fa563d8e076845d2657d956c4bcde51be444ee250aaaedae8814eb354130884a733ba6e9b9de5cfac3883d63da697f5db113973806362f
+  data.tar.gz: f3d265478cc4bba62e1eb27631da361d3249529d45ab06111babd9adbdd57223b954c23e49b5cdea9671d3c62067ea89254c19948b3b1acf66c62333f7a907c4

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem 'base64'
+gem 'logger'
+gem 'ostruct'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    svix (1.93.0)
+      base64 (~> 0.3.0)
+      logger (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.9.0)
+      public_suffix (>= 2.0.2, < 8.0)
+    base64 (0.3.0)
+    bigdecimal (4.1.1)
+    crack (1.0.1)
+      bigdecimal
+      rexml
+    diff-lcs (1.6.2)
+    hashdiff (1.2.1)
+    logger (1.7.0)
+    ostruct (0.6.3)
+    public_suffix (7.0.5)
+    rake (13.4.1)
+    rexml (3.4.4)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    webmock (3.26.2)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  base64
+  logger
+  ostruct
+  rake (~> 13.0)
+  rspec (~> 3.2)
+  svix!
+  webmock (~> 3.25)
+
+BUNDLED WITH
+   2.6.5

data/README.md

@@ -1,20 +1,13 @@
 # HookSniff Ruby SDK
 
-[![Gem](https://img.shields.io/gem/v/hooksniff.svg)](https://rubygems.org/gems/hooksniff)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+<p align="center">
+  <a href="https://github.com/servetarslan02/HookSniff"><img src="https://img.shields.io/github/license/servetarslan02/HookSniff" alt="License"></a>
+</p>
 
-Official Ruby client for the [HookSniff](https://hooksniff.vercel.app) webhook delivery service.
+Ruby SDK for the [HookSniff](https://hooksniff.com) webhook delivery platform.
 
 ## Installation
 
-Add to your Gemfile:
-
-```ruby
-gem "hooksniff"
-```
-
-Or install directly:
-
 ```bash
 gem install hooksniff
 ```
@@ -24,200 +17,31 @@ gem install hooksniff
 ```ruby
 require "hooksniff"
 
-# Initialize client
-client = HookSniff::Client.new(api_key: "hr_live_your_api_key_here")
-
-# Create a webhook endpoint
-endpoint = client.endpoints.create(
-  url: "https://myapp.com/webhook",
-  description: "Order notifications"
-)
-puts "Endpoint created: #{endpoint[:id]}"
-
-# Send a webhook
-delivery = client.webhooks.send(
-  endpoint_id: endpoint[:id],
-  event: "order.created",
-  data: { order_id: "12345", amount: 99.99 }
-)
-puts "Delivery queued: #{delivery[:id]}, status: #{delivery[:status]}"
-
-# Check delivery status
-status = client.webhooks.get(delivery[:id])
-puts "Status: #{status[:status]}, attempts: #{status[:attempt_count]}"
-
-# List deliveries
-deliveries = client.webhooks.list(status: "failed", page: 1)
-deliveries[:deliveries].each do |d|
-  puts "  #{d[:id]}: #{d[:status]}"
-end
-
-# Replay a failed delivery
-replayed = client.webhooks.replay(delivery[:id])
-puts "Replay queued: #{replayed[:id]}"
+client = HookSniff::Client.new("hs_xxx")
+endpoints = client.endpoint.list
+puts endpoints
 ```
 
-## Batch Webhooks
-
-Send multiple webhooks in a single request (max 100):
+## Webhook Verification
 
 ```ruby
-results = client.webhooks.batch([
-  { endpoint_id: "ep_1", event: "order.created", data: { order_id: "12345" } },
-  { endpoint_id: "ep_2", event: "payment.completed", data: { payment_id: "pay_67890" } }
-])
-
-puts "Delivered: #{results[:deliveries].length}"
-puts "Errors: #{results[:errors].length}"
-results[:errors].each do |err|
-  puts "  Item #{err['index']}: #{err['error']}"
-end
+wh = HookSniff::Webhook.new("whsec_xxx")
+payload = wh.verify(body, headers)
 ```
 
-## Retry Policy
-
-Configure custom retry behavior when creating endpoints:
-
-```ruby
-endpoint = client.endpoints.create(
-  url: "https://myapp.com/webhook",
-  description: "Critical notifications",
-  retry_policy: {
-    max_attempts: 5,
-    backoff: "exponential",
-    initial_delay_secs: 10,
-    max_delay_secs: 3600
-  }
-)
-```
-
-## Delivery Attempts
-
-Inspect individual delivery attempts:
-
-```ruby
-attempts = client.webhooks.attempts(delivery[:id])
-attempts.each do |attempt|
-  puts "  Attempt #{attempt[:attempt_number]}: status=#{attempt[:status_code]}, " \
-       "duration=#{attempt[:duration_ms]}ms"
-  puts "    Error: #{attempt[:error_message]}" if attempt[:error_message]
-end
-```
-
-## Export Logs
-
-Export webhook logs as JSON or CSV:
-
-```ruby
-# JSON export
-logs = client.webhooks.export(format: "json", status: "failed")
-
-# CSV export
-csv_data = client.webhooks.export(format: "csv", date_from: "2024-01-01")
-File.write("webhooks.csv", csv_data)
-```
-
-## Signature Verification
-
-Verify incoming webhook signatures in your handler:
-
-```ruby
-require "hooksniff"
-require "sinatra"
-
-post "/webhook" do
-  payload = request.body.read
-  signature = request.env["HTTP_X_HOOKSNIFF_SIGNATURE"]
-  secret = "whsec_your_endpoint_signing_secret"
-
-  unless HookSniff.verify_signature(payload, signature, secret)
-    halt 401, { error: "Invalid signature" }.to_json
-  end
-
-  data = JSON.parse(payload)
-  puts "Received event: #{data['event']}"
-  content_type :json
-  { received: true }.to_json
-end
-```
-
-### Standard Webhooks Verification
-
-For Standard Webhooks compatible verification:
-
-```ruby
-result = HookSniff.verify_webhook(
-  payload: request.body.read,
-  msg_id: request.env["HTTP_WEBHOOK_ID"],
-  timestamp: request.env["HTTP_WEBHOOK_TIMESTAMP"],
-  signature_header: request.env["HTTP_WEBHOOK_SIGNATURE"],
-  secret: "whsec_..."
-)
-
-unless result[:valid]
-  halt 401, { error: result[:error] }.to_json
-end
-
-puts "Event: #{result[:payload]['event']}"
-```
-
-## Error Handling
-
-```ruby
-begin
-  delivery = client.webhooks.send(
-    endpoint_id: "nonexistent",
-    event: "test.event",
-    data: { test: true }
-  )
-rescue HookSniff::AuthenticationError => e
-  puts "Invalid API key"
-rescue HookSniff::NotFoundError => e
-  puts "Endpoint not found"
-rescue HookSniff::RateLimitError => e
-  puts "Rate limit exceeded - try again later"
-rescue HookSniff::ValidationError => e
-  puts "Invalid request: #{e.message}"
-rescue HookSniff::PayloadTooLargeError => e
-  puts "Payload exceeds maximum size"
-end
-```
-
-## API Reference
-
-### `HookSniff::Client.new(api_key:, base_url: nil, timeout: nil)`
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `api_key` | `String` | required | Your HookSniff API key |
-| `base_url` | `String` | `https://hooksniff-api-1046140057667.europe-west1.run.app/v1` | API base URL |
-| `timeout` | `Integer` | `30` | Request timeout in seconds |
-
-### `client.endpoints`
-
-- `.create(url:, description: nil, retry_policy: nil)` → `Hash`
-- `.get(endpoint_id)` → `Hash`
-- `.list` → `Array<Hash>`
-- `.delete(endpoint_id)` → `Boolean`
-
-### `client.webhooks`
-
-- `.send(endpoint_id:, data:, event: nil)` → `Hash`
-- `.get(delivery_id)` → `Hash`
-- `.list(status: nil, page: 1, per_page: 20)` → `Hash`
-- `.replay(delivery_id)` → `Hash`
-- `.batch(webhooks)` → `Hash`
-- `.attempts(delivery_id)` → `Array<Hash>`
-- `.export(format: nil, status: nil, date_from: nil, date_to: nil)` → `Array<Hash> | String`
-
-### `HookSniff.verify_signature(payload, signature, secret)` → `Boolean`
-
-Verify a webhook signature using HMAC-SHA256.
-
-### `HookSniff.verify_webhook(payload:, msg_id:, timestamp:, signature_header:, secret:, tolerance_secs: 300)` → `Hash`
+## Resources
 
-Verify a webhook using Standard Webheaders headers.
+| Resource | Methods |
+|----------|---------|
+| Endpoint | list, create, get, update, delete |
+| Message | create, list, get |
+| MessageAttempt | list, listByMsg, get, resend |
+| Authentication | dashboardAccess |
+| EventType | list |
+| Statistics | aggregate |
 
-## License
+## Links
 
-MIT
+- [Documentation](https://docs.hooksniff.com)
+- [API Reference](https://api.hooksniff.com)
+- [GitHub](https://github.com/servetarslan02/HookSniff)

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/hooksniff.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hooksniff/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hooksniff"
+  spec.version       = HookSniff::VERSION
+  spec.authors       = ["HookSniff"]
+  spec.email         = ["support@hooksniff.vercel.app"]
+  spec.license       = "MIT"
+
+  spec.summary       = "HookSniff webhooks API client and webhook verification library"
+  spec.description   = "HookSniff makes webhooks easy and reliable. " \
+                       "Learn more at https://hooksniff.vercel.app"
+  spec.homepage      = "https://hooksniff.vercel.app"
+
+  spec.required_ruby_version = ">= 3.2"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/servetarslan02/HookSniff"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  ignored = Regexp.union(
+    /\Aspec/,
+    /\Apkg/,
+    /\A.gitignore/,
+    /.gem\z/
+  )
+  spec.files = Dir['**/*'].reject {|f| !File.file?(f) || ignored.match(f) }
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "base64", "~> 0.3.0"
+  spec.add_dependency "logger", "~> 1.0"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "webmock", "~> 3.25"
+end

data/lib/hooksniff/api/authentication.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module HookSniff
+  class Authentication
+    def initialize(client)
+      @client = client
+    end
+
+    def app_portal_access(app_id, app_portal_access_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/v1/auth/portal-access/#{app_id}",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: app_portal_access_in
+      )
+      DashboardAccessOut.deserialize(res)
+    end
+
+    def logout(options = {})
+      options = options.transform_keys(&:to_s)
+      @client.execute_request(
+        "POST",
+        "/v1/auth/logout",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        }
+      )
+      nil
+    end
+  end
+end

data/lib/hooksniff/api/endpoint.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module HookSniff
+  class Endpoint
+    def initialize(client)
+      @client = client
+    end
+
+    def list(options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/v1/endpoints",
+        query_params: {
+          "limit" => options["limit"],
+          "offset" => options["offset"]
+        }
+      )
+      ListResponseEndpointOut.deserialize(res)
+    end
+
+    def create(endpoint_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/v1/endpoints",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: endpoint_in
+      )
+      EndpointOut.deserialize(res)
+    end
+
+    def get(endpoint_id)
+      res = @client.execute_request("GET", "/v1/endpoints/#{endpoint_id}")
+      EndpointOut.deserialize(res)
+    end
+
+    def update(endpoint_id, endpoint_update)
+      res = @client.execute_request(
+        "PUT",
+        "/v1/endpoints/#{endpoint_id}",
+        body: endpoint_update
+      )
+      EndpointOut.deserialize(res)
+    end
+
+    def patch(endpoint_id, endpoint_patch)
+      res = @client.execute_request(
+        "PATCH",
+        "/v1/endpoints/#{endpoint_id}",
+        body: endpoint_patch
+      )
+      EndpointOut.deserialize(res)
+    end
+
+    def delete(endpoint_id)
+      @client.execute_request("DELETE", "/v1/endpoints/#{endpoint_id}")
+      nil
+    end
+
+    def rotate_secret(endpoint_id, endpoint_secret_rotate_in)
+      res = @client.execute_request(
+        "POST",
+        "/v1/endpoints/#{endpoint_id}/rotate-secret",
+        body: endpoint_secret_rotate_in
+      )
+      EndpointSecretOut.deserialize(res)
+    end
+
+    def get_headers(endpoint_id)
+      res = @client.execute_request("GET", "/v1/endpoints/#{endpoint_id}/headers")
+      EndpointHeadersOut.deserialize(res)
+    end
+
+    def update_headers(endpoint_id, endpoint_headers_in)
+      @client.execute_request(
+        "PUT",
+        "/v1/endpoints/#{endpoint_id}/headers",
+        body: endpoint_headers_in
+      )
+      nil
+    end
+
+    def patch_headers(endpoint_id, endpoint_headers_patch_in)
+      @client.execute_request(
+        "PATCH",
+        "/v1/endpoints/#{endpoint_id}/headers",
+        body: endpoint_headers_patch_in
+      )
+      nil
+    end
+
+    def get_secret(endpoint_id)
+      res = @client.execute_request("GET", "/v1/endpoints/#{endpoint_id}/secret")
+      EndpointSecretOut.deserialize(res)
+    end
+  end
+end

data/lib/hooksniff/api/event_type.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module HookSniff
+  class EventType
+    def initialize(client)
+      @client = client
+    end
+
+    def list(options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/v1/event-types",
+        query_params: {
+          "limit" => options["limit"],
+          "offset" => options["offset"],
+          "include_archived" => options["include_archived"]
+        }
+      )
+      ListResponseEventTypeOut.deserialize(res)
+    end
+
+    def create(event_type_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/v1/event-types",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: event_type_in
+      )
+      EventTypeOut.deserialize(res)
+    end
+
+    def get(event_type_name)
+      res = @client.execute_request("GET", "/v1/event-types/#{event_type_name}")
+      EventTypeOut.deserialize(res)
+    end
+
+    def update(event_type_name, event_type_update)
+      res = @client.execute_request(
+        "PUT",
+        "/v1/event-types/#{event_type_name}",
+        body: event_type_update
+      )
+      EventTypeOut.deserialize(res)
+    end
+
+    def patch(event_type_name, event_type_patch)
+      res = @client.execute_request(
+        "PATCH",
+        "/v1/event-types/#{event_type_name}",
+        body: event_type_patch
+      )
+      EventTypeOut.deserialize(res)
+    end
+
+    def delete(event_type_name)
+      @client.execute_request("DELETE", "/v1/event-types/#{event_type_name}")
+      nil
+    end
+  end
+end

data/lib/hooksniff/api/health.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module HookSniff
+  class Health
+    def initialize(client)
+      @client = client
+    end
+
+    def get
+      res = @client.execute_request("GET", "/v1/health")
+      res
+    end
+  end
+end

data/lib/hooksniff/api/message.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module HookSniff
+  class Message
+    def initialize(client)
+      @client = client
+    end
+
+    def create(message_in, options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "POST",
+        "/v1/webhooks",
+        headers: {
+          "idempotency-key" => options["idempotency-key"]
+        },
+        body: message_in
+      )
+      MessageOut.deserialize(res)
+    end
+
+    def list(options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/v1/webhooks",
+        query_params: {
+          "limit" => options["limit"],
+          "offset" => options["offset"],
+          "status" => options["status"]
+        }
+      )
+      ListResponseMessageOut.deserialize(res)
+    end
+
+    def get(message_id)
+      res = @client.execute_request("GET", "/v1/webhooks/#{message_id}")
+      MessageOut.deserialize(res)
+    end
+
+    def replay(message_id)
+      res = @client.execute_request("POST", "/v1/webhooks/#{message_id}/replay")
+      ReplayOut.deserialize(res)
+    end
+  end
+end

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