sendly 1.1.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f970f1462ecd9facfec70a5ba0b167e5da0c697f1dcb96203874f1325cb1b03
-  data.tar.gz: d5b5ab964db06976dd6a848d137f5b2b8af07607c795ad4dd96d729ae4c37285
+  metadata.gz: 8287e0f6c55aa228285671746446a7eb04577569e56515ed76571da61a0392b0
+  data.tar.gz: 62017808d07348e8d6e5809b367300e11976a754e7c3323c8155d2d9140befb4
 SHA512:
-  metadata.gz: d110ea4e88716ef5299c77d37d47ac55817f796113e7ebdadb21aed864d1ad1fcb2f082c724b50e20a4c473fd762ae69726e4b1b0907a21a982886a6719a1fc5
-  data.tar.gz: 31ac699cd4fc8305ba04c3ba829fcc5be63436811a6be8ce9606b69641ee401b9b0d17b2b91afccc3210677d006bd244efc35ef9ad6ce7cc4838f724dbb7fc72
+  metadata.gz: 2c3a234e3caa740975c00ad3c1454dbe24f423385f480f180e33f1ac0ef890bbe019f58606ff3f50bb0b508280d9352997dd20b88a6705d277d493235d3ecc57
+  data.tar.gz: 5e7cba5b80ec78994f3de8b0dfe5c3f63f6c00cede6f5a98c3d7a679755386ee543477f588c672c248181dbfc279bd8834c5108f1a1071378f9e51b23ea94c40

data/Gemfile.lock

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

data/README.md

@@ -4,17 +4,24 @@ Official Ruby SDK for the Sendly SMS API.
 
 ## Installation
 
-```bash
-# gem
-gem install sendly
+Add to your Gemfile:
 
-# Bundler (add to Gemfile)
+```ruby
 gem 'sendly'
+```
+
+Then run:
 
-# then run
+```bash
 bundle install
 ```
 
+Or install directly:
+
+```bash
+gem install sendly
+```
+
 ## Quick Start
 
 ```ruby
@@ -75,7 +82,7 @@ Sendly.send_message(to: "+15551234567", text: "Hello!")
 ```ruby
 client = Sendly::Client.new(
   "sk_live_v1_xxx",
-  base_url: "https://sendly.live/api/v1",
+  base_url: "https://api.sendly.live/v1",
   timeout: 60,
   max_retries: 5
 )

data/lib/sendly/client.rb

@@ -45,20 +45,6 @@ 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
@@ -77,15 +63,6 @@ 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
@@ -160,8 +137,6 @@ 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,9 +18,6 @@ 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
 
@@ -33,29 +30,14 @@ 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 (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
+    # Message status constants
+    STATUSES = %w[queued sending sent delivered failed].freeze
 
     def initialize(data)
       @id = data["id"]
@@ -63,15 +45,10 @@ 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
@@ -103,15 +80,10 @@ 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
@@ -187,269 +159,4 @@ 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.1.0"
+  VERSION = "1.5.1"
 end

data/lib/sendly.rb

@@ -9,8 +9,6 @@ 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,13 @@
 --- !ruby/object:Gem::Specification
 name: sendly
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Sendly
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -123,14 +122,12 @@ 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
@@ -139,7 +136,6 @@ metadata:
   source_code_uri: https://github.com/sendly-live/sendly-ruby
   changelog_uri: https://github.com/sendly-live/sendly-ruby/blob/main/CHANGELOG.md
   documentation_uri: https://sendly.live/docs
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -154,8 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Official Ruby SDK for the Sendly SMS API
 test_files: []

data/lib/sendly/account_resource.rb

@@ -1,70 +0,0 @@
-# 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/webhooks_resource.rb

@@ -1,149 +0,0 @@
-# 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