sendly 1.0.8 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34504d5c13852809e988bb03d13a1a0fce105fc1034854a8a1f6665316ea346e
-  data.tar.gz: dd2474f813d01734670a9a2bc09b2094afc379df5ab3f77abcc4d9adb44c4f89
+  metadata.gz: 5f970f1462ecd9facfec70a5ba0b167e5da0c697f1dcb96203874f1325cb1b03
+  data.tar.gz: d5b5ab964db06976dd6a848d137f5b2b8af07607c795ad4dd96d729ae4c37285
 SHA512:
-  metadata.gz: e0bccfd75de393fd5cd22edd80b6fb07781f63825a01245c489cedf2439ee907e8c51e6d8748bf557a5839aed3fccc43e5d6b85ca190a57127744d8273aad339
-  data.tar.gz: 6bb92db07cc8bb89c983270b4d05bfc2872fb2dde25e6fb099fdfc98b28de9d950e86aaddd32f3e0b42d437517e7df041838caa5f22d1074aee7864f679d33fa
+  metadata.gz: d110ea4e88716ef5299c77d37d47ac55817f796113e7ebdadb21aed864d1ad1fcb2f082c724b50e20a4c473fd762ae69726e4b1b0907a21a982886a6719a1fc5
+  data.tar.gz: 31ac699cd4fc8305ba04c3ba829fcc5be63436811a6be8ce9606b69641ee401b9b0d17b2b91afccc3210677d006bd244efc35ef9ad6ce7cc4838f724dbb7fc72

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sendly (1.0.8)
+    sendly (1.1.0)
       faraday (~> 2.0)
       faraday-retry (~> 2.0)
 

data/lib/sendly/account_resource.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Sendly
+  # Account resource for accessing account information, credits, and API keys
+  class AccountResource
+    # @param client [Sendly::Client] The API client
+    def initialize(client)
+      @client = client
+    end
+
+    # Get account information
+    #
+    # @return [Sendly::Account]
+    def get
+      response = @client.get("/account")
+      Account.new(response)
+    end
+
+    # Get credit balance
+    #
+    # @return [Sendly::Credits]
+    #
+    # @example
+    #   credits = client.account.credits
+    #   puts "Available: #{credits.available_balance} credits"
+    def credits
+      response = @client.get("/credits")
+      Credits.new(response)
+    end
+
+    # Get credit transaction history
+    #
+    # @param limit [Integer, nil] Maximum number of transactions to return
+    # @param offset [Integer, nil] Number of transactions to skip
+    # @return [Array<Sendly::CreditTransaction>]
+    def transactions(limit: nil, offset: nil)
+      params = {}
+      params[:limit] = limit if limit
+      params[:offset] = offset if offset
+
+      response = @client.get("/credits/transactions", params)
+      response.map { |data| CreditTransaction.new(data) }
+    end
+
+    # List API keys for the account
+    #
+    # @return [Array<Sendly::ApiKey>]
+    def api_keys
+      response = @client.get("/keys")
+      response.map { |data| ApiKey.new(data) }
+    end
+
+    # Get a specific API key by ID
+    #
+    # @param key_id [String] API key ID
+    # @return [Sendly::ApiKey]
+    def api_key(key_id)
+      response = @client.get("/keys/#{key_id}")
+      ApiKey.new(response)
+    end
+
+    # Get usage statistics for an API key
+    #
+    # @param key_id [String] API key ID
+    # @return [Hash] Usage statistics
+    def api_key_usage(key_id)
+      @client.get("/keys/#{key_id}/usage")
+    end
+  end
+end

data/lib/sendly/client.rb

@@ -45,6 +45,20 @@ module Sendly
       @messages ||= Messages.new(self)
     end
 
+    # Access the Webhooks resource
+    #
+    # @return [Sendly::WebhooksResource]
+    def webhooks
+      @webhooks ||= WebhooksResource.new(self)
+    end
+
+    # Access the Account resource
+    #
+    # @return [Sendly::AccountResource]
+    def account
+      @account ||= AccountResource.new(self)
+    end
+
     # Make a GET request
     #
     # @param path [String] API path
@@ -63,6 +77,15 @@ module Sendly
       request(:post, path, body: body)
     end
 
+    # Make a PATCH request
+    #
+    # @param path [String] API path
+    # @param body [Hash] Request body
+    # @return [Hash] Response body
+    def patch(path, body = {})
+      request(:patch, path, body: body)
+    end
+
     # Make a DELETE request
     #
     # @param path [String] API path
@@ -137,6 +160,8 @@ module Sendly
               Net::HTTP::Get.new(uri)
             when :post
               Net::HTTP::Post.new(uri)
+            when :patch
+              Net::HTTP::Patch.new(uri)
             when :delete
               Net::HTTP::Delete.new(uri)
             else

data/lib/sendly/types.rb

@@ -18,6 +18,9 @@ module Sendly
     # @return [String] Delivery status
     attr_reader :status
 
+    # @return [String] Message direction (outbound or inbound)
+    attr_reader :direction
+
     # @return [String, nil] Error message if failed
     attr_reader :error
 
@@ -30,14 +33,29 @@ module Sendly
     # @return [Boolean] Whether sent in sandbox mode
     attr_reader :is_sandbox
 
+    # @return [String, nil] How the message was sent (number_pool, alphanumeric, sandbox)
+    attr_reader :sender_type
+
+    # @return [String, nil] Telnyx message ID for tracking
+    attr_reader :telnyx_message_id
+
+    # @return [String, nil] Warning message
+    attr_reader :warning
+
+    # @return [String, nil] Note about sender behavior
+    attr_reader :sender_note
+
     # @return [Time, nil] Creation timestamp
     attr_reader :created_at
 
     # @return [Time, nil] Delivery timestamp
     attr_reader :delivered_at
 
-    # Message status constants
-    STATUSES = %w[queued sending sent delivered failed].freeze
+    # Message status constants (sending removed - doesn't exist in database)
+    STATUSES = %w[queued sent delivered failed].freeze
+
+    # Sender type constants
+    SENDER_TYPES = %w[number_pool alphanumeric sandbox].freeze
 
     def initialize(data)
       @id = data["id"]
@@ -45,10 +63,15 @@ module Sendly
       @from = data["from"]
       @text = data["text"]
       @status = data["status"]
+      @direction = data["direction"] || "outbound"
       @error = data["error"]
       @segments = data["segments"] || 1
       @credits_used = data["creditsUsed"] || 0
       @is_sandbox = data["isSandbox"] || false
+      @sender_type = data["senderType"]
+      @telnyx_message_id = data["telnyxMessageId"]
+      @warning = data["warning"]
+      @sender_note = data["senderNote"]
       @created_at = parse_time(data["createdAt"])
       @delivered_at = parse_time(data["deliveredAt"])
     end
@@ -80,10 +103,15 @@ module Sendly
         from: from,
         text: text,
         status: status,
+        direction: direction,
         error: error,
         segments: segments,
         credits_used: credits_used,
         is_sandbox: is_sandbox,
+        sender_type: sender_type,
+        telnyx_message_id: telnyx_message_id,
+        warning: warning,
+        sender_note: sender_note,
         created_at: created_at&.iso8601,
         delivered_at: delivered_at&.iso8601
       }.compact
@@ -159,4 +187,269 @@ module Sendly
       data.last
     end
   end
+
+  # ============================================================================
+  # Webhooks
+  # ============================================================================
+
+  # Represents a configured webhook endpoint
+  class Webhook
+    attr_reader :id, :url, :events, :description, :is_active, :failure_count,
+                :last_failure_at, :circuit_state, :circuit_opened_at, :api_version,
+                :metadata, :created_at, :updated_at, :total_deliveries,
+                :successful_deliveries, :success_rate, :last_delivery_at
+
+    # Circuit state constants
+    CIRCUIT_STATES = %w[closed open half_open].freeze
+
+    def initialize(data)
+      @id = data["id"]
+      @url = data["url"]
+      @events = data["events"] || []
+      @description = data["description"]
+      # Handle both snake_case API response and camelCase
+      @is_active = data["is_active"] || data["isActive"] || false
+      @failure_count = data["failure_count"] || data["failureCount"] || 0
+      @last_failure_at = parse_time(data["last_failure_at"] || data["lastFailureAt"])
+      @circuit_state = data["circuit_state"] || data["circuitState"] || "closed"
+      @circuit_opened_at = parse_time(data["circuit_opened_at"] || data["circuitOpenedAt"])
+      @api_version = data["api_version"] || data["apiVersion"] || "2024-01"
+      @metadata = data["metadata"] || {}
+      @created_at = parse_time(data["created_at"] || data["createdAt"])
+      @updated_at = parse_time(data["updated_at"] || data["updatedAt"])
+      @total_deliveries = data["total_deliveries"] || data["totalDeliveries"] || 0
+      @successful_deliveries = data["successful_deliveries"] || data["successfulDeliveries"] || 0
+      @success_rate = data["success_rate"] || data["successRate"] || 0
+      @last_delivery_at = parse_time(data["last_delivery_at"] || data["lastDeliveryAt"])
+    end
+
+    def active?
+      is_active
+    end
+
+    def circuit_open?
+      circuit_state == "open"
+    end
+
+    def to_h
+      {
+        id: id, url: url, events: events, description: description,
+        is_active: is_active, failure_count: failure_count,
+        circuit_state: circuit_state, api_version: api_version,
+        metadata: metadata, total_deliveries: total_deliveries,
+        successful_deliveries: successful_deliveries, success_rate: success_rate
+      }.compact
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      Time.parse(value)
+    rescue ArgumentError
+      nil
+    end
+  end
+
+  # Webhook with secret (returned on creation)
+  class WebhookCreatedResponse < Webhook
+    attr_reader :secret
+
+    def initialize(data)
+      super(data)
+      @secret = data["secret"]
+    end
+  end
+
+  # Represents a webhook delivery attempt
+  class WebhookDelivery
+    attr_reader :id, :webhook_id, :event_id, :event_type, :attempt_number,
+                :max_attempts, :status, :response_status_code, :response_time_ms,
+                :error_message, :error_code, :next_retry_at, :created_at, :delivered_at
+
+    # Delivery status constants
+    STATUSES = %w[pending delivered failed cancelled].freeze
+
+    def initialize(data)
+      @id = data["id"]
+      @webhook_id = data["webhook_id"] || data["webhookId"]
+      @event_id = data["event_id"] || data["eventId"]
+      @event_type = data["event_type"] || data["eventType"]
+      @attempt_number = data["attempt_number"] || data["attemptNumber"] || 1
+      @max_attempts = data["max_attempts"] || data["maxAttempts"] || 6
+      @status = data["status"]
+      @response_status_code = data["response_status_code"] || data["responseStatusCode"]
+      @response_time_ms = data["response_time_ms"] || data["responseTimeMs"]
+      @error_message = data["error_message"] || data["errorMessage"]
+      @error_code = data["error_code"] || data["errorCode"]
+      @next_retry_at = parse_time(data["next_retry_at"] || data["nextRetryAt"])
+      @created_at = parse_time(data["created_at"] || data["createdAt"])
+      @delivered_at = parse_time(data["delivered_at"] || data["deliveredAt"])
+    end
+
+    def delivered?
+      status == "delivered"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      Time.parse(value)
+    rescue ArgumentError
+      nil
+    end
+  end
+
+  # Result of testing a webhook
+  class WebhookTestResult
+    attr_reader :success, :status_code, :response_time_ms, :error
+
+    def initialize(data)
+      @success = data["success"]
+      @status_code = data["status_code"] || data["statusCode"]
+      @response_time_ms = data["response_time_ms"] || data["responseTimeMs"]
+      @error = data["error"]
+    end
+
+    def success?
+      success
+    end
+  end
+
+  # Result of rotating webhook secret
+  class WebhookSecretRotation
+    attr_reader :webhook, :new_secret, :old_secret_expires_at, :message
+
+    def initialize(data)
+      @webhook = Webhook.new(data["webhook"])
+      @new_secret = data["new_secret"] || data["newSecret"]
+      @old_secret_expires_at = parse_time(data["old_secret_expires_at"] || data["oldSecretExpiresAt"])
+      @message = data["message"]
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      Time.parse(value)
+    rescue ArgumentError
+      nil
+    end
+  end
+
+  # ============================================================================
+  # Account & Credits
+  # ============================================================================
+
+  # Represents account information
+  class Account
+    attr_reader :id, :email, :name, :created_at
+
+    def initialize(data)
+      @id = data["id"]
+      @email = data["email"]
+      @name = data["name"]
+      @created_at = parse_time(data["created_at"] || data["createdAt"])
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      Time.parse(value)
+    rescue ArgumentError
+      nil
+    end
+  end
+
+  # Represents credit balance information
+  class Credits
+    attr_reader :balance, :reserved_balance, :available_balance
+
+    def initialize(data)
+      @balance = data["balance"] || 0
+      @reserved_balance = data["reserved_balance"] || data["reservedBalance"] || 0
+      @available_balance = data["available_balance"] || data["availableBalance"] || 0
+    end
+  end
+
+  # Represents a credit transaction
+  class CreditTransaction
+    attr_reader :id, :type, :amount, :balance_after, :description, :message_id, :created_at
+
+    # Transaction type constants
+    TYPES = %w[purchase usage refund adjustment bonus].freeze
+
+    def initialize(data)
+      @id = data["id"]
+      @type = data["type"]
+      @amount = data["amount"] || 0
+      @balance_after = data["balance_after"] || data["balanceAfter"] || 0
+      @description = data["description"]
+      @message_id = data["message_id"] || data["messageId"]
+      @created_at = parse_time(data["created_at"] || data["createdAt"])
+    end
+
+    def credit?
+      amount > 0
+    end
+
+    def debit?
+      amount < 0
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      Time.parse(value)
+    rescue ArgumentError
+      nil
+    end
+  end
+
+  # Represents an API key
+  class ApiKey
+    attr_reader :id, :name, :type, :prefix, :last_four, :permissions,
+                :created_at, :last_used_at, :expires_at, :is_revoked
+
+    def initialize(data)
+      @id = data["id"]
+      @name = data["name"]
+      @type = data["type"]
+      @prefix = data["prefix"]
+      @last_four = data["last_four"] || data["lastFour"]
+      @permissions = data["permissions"] || []
+      @created_at = parse_time(data["created_at"] || data["createdAt"])
+      @last_used_at = parse_time(data["last_used_at"] || data["lastUsedAt"])
+      @expires_at = parse_time(data["expires_at"] || data["expiresAt"])
+      @is_revoked = data["is_revoked"] || data["isRevoked"] || false
+    end
+
+    def test?
+      type == "test"
+    end
+
+    def live?
+      type == "live"
+    end
+
+    def revoked?
+      is_revoked
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      Time.parse(value)
+    rescue ArgumentError
+      nil
+    end
+  end
 end

data/lib/sendly/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sendly
-  VERSION = "1.0.8"
+  VERSION = "1.1.0"
 end

data/lib/sendly/webhooks_resource.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Sendly
+  # Webhooks resource for managing webhook endpoints
+  class WebhooksResource
+    # @param client [Sendly::Client] The API client
+    def initialize(client)
+      @client = client
+    end
+
+    # Create a new webhook endpoint
+    #
+    # @param url [String] HTTPS endpoint URL
+    # @param events [Array<String>] Event types to subscribe to
+    # @param description [String, nil] Optional description
+    # @param metadata [Hash, nil] Custom metadata
+    # @return [Sendly::WebhookCreatedResponse]
+    #
+    # @example
+    #   webhook = client.webhooks.create(
+    #     url: "https://example.com/webhooks",
+    #     events: ["message.delivered", "message.failed"]
+    #   )
+    #   puts "Secret: #{webhook.secret}"  # Save this - only shown once!
+    def create(url:, events:, description: nil, metadata: nil)
+      raise ArgumentError, "Webhook URL must be HTTPS" unless url&.start_with?("https://")
+      raise ArgumentError, "At least one event type is required" if events.nil? || events.empty?
+
+      body = { url: url, events: events }
+      body[:description] = description if description
+      body[:metadata] = metadata if metadata
+
+      response = @client.post("/webhooks", body)
+      WebhookCreatedResponse.new(response)
+    end
+
+    # List all webhooks
+    #
+    # @return [Array<Sendly::Webhook>]
+    def list
+      response = @client.get("/webhooks")
+      response.map { |data| Webhook.new(data) }
+    end
+
+    # Get a specific webhook by ID
+    #
+    # @param webhook_id [String] Webhook ID (whk_xxx)
+    # @return [Sendly::Webhook]
+    def get(webhook_id)
+      validate_webhook_id!(webhook_id)
+      response = @client.get("/webhooks/#{webhook_id}")
+      Webhook.new(response)
+    end
+
+    # Update a webhook configuration
+    #
+    # @param webhook_id [String] Webhook ID
+    # @param url [String, nil] New URL
+    # @param events [Array<String>, nil] New event subscriptions
+    # @param description [String, nil] New description
+    # @param is_active [Boolean, nil] Enable/disable webhook
+    # @param metadata [Hash, nil] Custom metadata
+    # @return [Sendly::Webhook]
+    def update(webhook_id, url: nil, events: nil, description: nil, is_active: nil, metadata: nil)
+      validate_webhook_id!(webhook_id)
+      raise ArgumentError, "Webhook URL must be HTTPS" if url && !url.start_with?("https://")
+
+      body = {}
+      body[:url] = url unless url.nil?
+      body[:events] = events unless events.nil?
+      body[:description] = description unless description.nil?
+      body[:is_active] = is_active unless is_active.nil?
+      body[:metadata] = metadata unless metadata.nil?
+
+      response = @client.patch("/webhooks/#{webhook_id}", body)
+      Webhook.new(response)
+    end
+
+    # Delete a webhook
+    #
+    # @param webhook_id [String] Webhook ID
+    # @return [void]
+    def delete(webhook_id)
+      validate_webhook_id!(webhook_id)
+      @client.delete("/webhooks/#{webhook_id}")
+      nil
+    end
+
+    # Test a webhook endpoint
+    #
+    # @param webhook_id [String] Webhook ID
+    # @return [Sendly::WebhookTestResult]
+    def test(webhook_id)
+      validate_webhook_id!(webhook_id)
+      response = @client.post("/webhooks/#{webhook_id}/test")
+      WebhookTestResult.new(response)
+    end
+
+    # Rotate the webhook signing secret
+    #
+    # @param webhook_id [String] Webhook ID
+    # @return [Sendly::WebhookSecretRotation]
+    def rotate_secret(webhook_id)
+      validate_webhook_id!(webhook_id)
+      response = @client.post("/webhooks/#{webhook_id}/rotate-secret")
+      WebhookSecretRotation.new(response)
+    end
+
+    # Get delivery history for a webhook
+    #
+    # @param webhook_id [String] Webhook ID
+    # @return [Array<Sendly::WebhookDelivery>]
+    def deliveries(webhook_id)
+      validate_webhook_id!(webhook_id)
+      response = @client.get("/webhooks/#{webhook_id}/deliveries")
+      response.map { |data| WebhookDelivery.new(data) }
+    end
+
+    # Retry a failed delivery
+    #
+    # @param webhook_id [String] Webhook ID
+    # @param delivery_id [String] Delivery ID
+    # @return [void]
+    def retry_delivery(webhook_id, delivery_id)
+      validate_webhook_id!(webhook_id)
+      validate_delivery_id!(delivery_id)
+      @client.post("/webhooks/#{webhook_id}/deliveries/#{delivery_id}/retry")
+      nil
+    end
+
+    # List available event types
+    #
+    # @return [Array<String>]
+    def event_types
+      response = @client.get("/webhooks/event-types")
+      (response["events"] || []).map { |e| e["type"] }
+    end
+
+    private
+
+    def validate_webhook_id!(webhook_id)
+      raise ArgumentError, "Invalid webhook ID format" unless webhook_id&.start_with?("whk_")
+    end
+
+    def validate_delivery_id!(delivery_id)
+      raise ArgumentError, "Invalid delivery ID format" unless delivery_id&.start_with?("del_")
+    end
+  end
+end

data/lib/sendly.rb

@@ -9,6 +9,8 @@ require_relative "sendly/types"
 require_relative "sendly/client"
 require_relative "sendly/messages"
 require_relative "sendly/webhooks"
+require_relative "sendly/webhooks_resource"
+require_relative "sendly/account_resource"
 
 # Sendly Ruby SDK
 #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sendly
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.1.0
 platform: ruby
 authors:
 - Sendly
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-20 00:00:00.000000000 Z
+date: 2025-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -123,12 +123,14 @@ files:
 - examples/list_messages.rb
 - examples/send_sms.rb
 - lib/sendly.rb
+- lib/sendly/account_resource.rb
 - lib/sendly/client.rb
 - lib/sendly/errors.rb
 - lib/sendly/messages.rb
 - lib/sendly/types.rb
 - lib/sendly/version.rb
 - lib/sendly/webhooks.rb
+- lib/sendly/webhooks_resource.rb
 homepage: https://github.com/sendly-live/sendly-ruby
 licenses:
 - MIT