relaygrid 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d0cc0707a44f80cc25e92aad237601e2fc3ec3f8ea2bd455facb68180843196
-  data.tar.gz: 237cd1b6377a7b4a8fc3ba57287da93990620efc3c6971af67277defcd50b886
+  metadata.gz: '08c77a1f6d4cf7d515c07899a1b7ec8e30a590921fff71bf0261cc2caa58fc86'
+  data.tar.gz: 0a4d7357d29d5fada986ac8bc2cf67b6a87c833a410f47a1d15590665bd06d4b
 SHA512:
-  metadata.gz: 289569fcadc3c5d298ea4450a0ee00c33e21db743725ef9116aff25206b5c5fcf10ae3564434fb6a8a08af8b31c138e67a9cf79e64debcbef9d5616ba51e3672
-  data.tar.gz: 30de0ca4b93b88a2740787d1ce97eba72bf17807fe9af59eb2df99041909a6d86916a76f64debc45a14af950c38dfb70627b9048898d06c410ec4580d7e4c37a
+  metadata.gz: fcc099fa99bc3f2312b16308b61ed94731284533fac178506a49dec418ee84bbdf118984f49f003c6076c931deb8eb2675c22f4d55e1c2966e58283125c19ef4
+  data.tar.gz: 9376cfbafd25399ecb4bc2aa8091bdbf95712d22d6713fca2db039823ddaedc790d111b1752b9bf360a4b9613a02cfe7c46df0ef03ce5178f15fe8239829b9e6

data/CHANGELOG.md

@@ -7,6 +7,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-08-06
+
+### Added
+
+- Inbound delivery-status webhooks. `RelayGrid::Webhooks.construct_event(body,
+  signature_header, secret)` verifies the `X-RelayGrid-Signature` HMAC against
+  the raw request body and returns a `RelayGrid::Event`; `verify_signature`
+  does the same check without building the event. The signed timestamp is
+  checked against a five-minute replay window by default (`tolerance:`), and
+  several `v1=` signatures in one header are accepted so a secret can be
+  rotated without dropping events.
+- `RelayGrid::Event` — immutable, with `id` (stable across retries, so it is
+  what you deduplicate on), `type`, `created_at`, `data`, `raw`, and a
+  `delivery` in exactly the shape `deliveries.get` returns, so webhook-driven
+  and polling handlers can be shared. Events are at-least-once and unordered;
+  branch on `event.delivery.status`, not on arrival order.
+- `RelayGrid::SignatureVerificationError`, raised for a bad signature, a
+  missing or malformed header, a timestamp outside the tolerance, or a body
+  that isn't JSON. Descends from `RelayGrid::Error` but deliberately not from
+  `APIError` — nothing failed on the wire.
+- `client.webhook_endpoints` to manage the account's one endpoint: `list`,
+  `current`, `get`, `create`, `update`, `delete`, `rotate_secret`,
+  `reactivate`, `test`, and `attempts` for the dispatch log. The plaintext
+  signing secret is returned by `create` and `rotate_secret` only.
+- `Delivery#retrying?` and `Delivery#terminal?`, plus the `retrying` status
+  constant and `TERMINAL_STATUSES`.
+
+### Changed
+
+- **`wait_for_deliveries` now returns as soon as every delivery is terminal,
+  successful or not.** The server reports an in-flight retry as `retrying`, so
+  `failed` finally means final — 0.1.x kept polling through a `failed` row and
+  raised `TimeoutWaitingForDeliveries` on a genuinely failed delivery. Code
+  that treated the return value as "everything succeeded" must now check
+  `settled.all?(&:success?)` itself.
+
 ## [0.1.1] - 2026-07-30
 
 ### Removed

data/README.md

@@ -149,9 +149,10 @@ delivery.friendly_error_message # => nil, or human-readable guidance when failed
 RelayGrid.client.deliveries.get_all([201, 202])  # one batched request
 ```
 
-Predicates: `queued?`, `sent?`, `delivered?`, `failed?`, `bounced?`, `opened?`,
-plus `success?` (delivered or opened). `#refresh` re-fetches and returns a new
-`Delivery` — the objects are immutable.
+Predicates: `queued?`, `sent?`, `delivered?`, `retrying?`, `failed?`, `bounced?`,
+`opened?`, plus `success?` (delivered or opened) and `terminal?` (the server will
+not move it on its own). `#refresh` re-fetches and returns a new `Delivery` — the
+objects are immutable.
 
 ### Waiting for deliveries to settle
 
@@ -160,14 +161,72 @@ settled = result.wait_for_deliveries(timeout: 30, interval: 2)
 settled.all?(&:success?) # => true
 ```
 
+It returns once every delivery is **terminal** — successful or not — so check
+`success?` yourself rather than treating a return as a win. A delivery the server
+is still retrying reads `retrying`, which is why `failed` means final.
+
 > **This blocks the calling thread.** Use it in a background job, a rake task, or
 > a script — never inside a web request, where it would pin a request thread for
 > up to `timeout` seconds. In a request, return `delivery_ids` and let the
 > browser poll, or subscribe over the websocket.
 
-`failed` is deliberately **not** treated as final inside the window: delivery
-jobs retry, so a failed delivery can still flip to `sent` and then `delivered`.
-The helper waits rather than reporting a transient failure as permanent.
+## Webhooks
+
+Registering an endpoint is what replaces polling for delivery status: RelayGrid
+posts `delivery.*` events to your app as they happen.
+
+```ruby
+endpoint = RelayGrid.client.webhook_endpoints.create(url: "https://app.example.com/relaygrid/webhooks")
+endpoint["secret"] # => "whsec_..." — returned here and by rotate_secret only, so store it now
+```
+
+An account has one endpoint. `current` returns it (or `nil`), `update(id, url:)`
+moves it, `test(id)` queues a signed `ping`, and `attempts(id)` is the dispatch
+log — response codes, errors, durations — for answering "why didn't my webhook
+arrive?". `rotate_secret(id)` issues a new secret and invalidates the old one
+immediately, so deploy the new one to your receiver first.
+
+### Verifying
+
+```ruby
+class RelayGridWebhooksController < ApplicationController
+  skip_before_action :verify_authenticity_token
+
+  def create
+    event = RelayGrid::Webhooks.construct_event(
+      request.raw_post,
+      request.headers["X-RelayGrid-Signature"],
+      ENV.fetch("RELAYGRID_WEBHOOK_SECRET")
+    )
+
+    case event.type
+    when "delivery.delivered" then mark_delivered(event.delivery.id)
+    when "delivery.failed"    then alert(event.delivery.friendly_error_message)
+    end
+
+    head :ok
+  rescue RelayGrid::SignatureVerificationError
+    head :bad_request
+  end
+end
+```
+
+Verify **before** you parse — it is the raw bytes that were signed, so
+re-serializing the JSON first will not verify. The HMAC proves the body came
+from RelayGrid unaltered, and the timestamp signed alongside it bounds how long
+a captured request stays replayable (five minutes; change it with `tolerance:`,
+or pass `nil` to disable the window).
+
+Two properties of the transport shape your handler:
+
+- **At-least-once.** The same `event.id` can arrive twice — a receiver that
+  times out after doing its work still gets retried. Key side-effects off `id`.
+- **Unordered.** `delivery.delivered` can arrive before `delivery.sent`. Branch
+  on `event.delivery.status`, which is the state at emission time, not on the
+  order events show up in.
+
+`event.delivery` is a `Delivery`, in exactly the shape `deliveries.get` returns,
+so webhook-driven and polling code can share handlers. It is `nil` for a `ping`.
 
 ## Receiving
 

data/lib/relaygrid/client.rb

@@ -67,6 +67,10 @@ module RelayGrid
       resource(:message_templates) { Resources::MessageTemplates.new(self) }
     end
 
+    def webhook_endpoints
+      resource(:webhook_endpoints) { Resources::WebhookEndpoints.new(self) }
+    end
+
     # Send a notification -- the one call the whole gem exists for.
     # See Resources::Notifications#notify.
     def notify(**kwargs)

data/lib/relaygrid/delivery.rb

@@ -11,13 +11,16 @@ module RelayGrid
     QUEUED = "queued"
     SENT = "sent"
     DELIVERED = "delivered"
+    RETRYING = "retrying"
     FAILED = "failed"
     BOUNCED = "bounced"
     OPENED = "opened"
 
-    # States the server will not move away from on its own.
     SUCCESS_STATUSES = [DELIVERED, OPENED].freeze
 
+    # States the server will not move away from on its own.
+    TERMINAL_STATUSES = (SUCCESS_STATUSES + [FAILED, BOUNCED]).freeze
+
     attr_reader :id, :message_id, :status, :channel_id, :channel_name, :channel_type,
                 :error_message, :friendly_error_message,
                 :sent_at, :delivered_at, :failed_at, :opened_at, :created_at, :updated_at,
@@ -60,6 +63,10 @@ module RelayGrid
       status == DELIVERED
     end
 
+    def retrying?
+      status == RETRYING
+    end
+
     def failed?
       status == FAILED
     end
@@ -73,14 +80,16 @@ module RelayGrid
     end
 
     # Reached a state the server considers final and successful.
-    #
-    # `failed` is deliberately *not* terminal: delivery jobs retry, so a failed
-    # row can still flip to `sent`. This mirrors the dashboard's polling
-    # semantics (see docs/DELIVERY_STATUS_PLAN.md in the API repo).
     def success?
       SUCCESS_STATUSES.include?(status)
     end
 
+    # Reached a state the server will not move away from on its own. A delivery
+    # being retried is `retrying`, not `failed`, so `failed` is final.
+    def terminal?
+      TERMINAL_STATUSES.include?(status)
+    end
+
     def push?
       channel_type == "push"
     end

data/lib/relaygrid/errors.rb

@@ -91,6 +91,13 @@ module RelayGrid
   # 5xx -- a fault on the RelayGrid side. Safe to retry for reads.
   class ServerError < APIError; end
 
+  # An inbound webhook could not be trusted: the signature didn't match, the
+  # header was missing or malformed, or the timestamp fell outside the replay
+  # tolerance. Answer these with a 400 and drop the request -- never process the
+  # body. Deliberately not an APIError: nothing failed on the wire, the payload
+  # simply isn't ours.
+  class SignatureVerificationError < Error; end
+
   # `wait_for_deliveries` gave up before every delivery reached a terminal
   # state. Carries the deliveries as last seen so the caller can inspect them.
   class TimeoutWaitingForDeliveries < Error

data/lib/relaygrid/event.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RelayGrid
+  # A verified delivery-status webhook, as returned by
+  # RelayGrid::Webhooks.construct_event.
+  #
+  #   case event.type
+  #   when "delivery.delivered" then mark_delivered(event.delivery.id)
+  #   when "delivery.failed"    then alert(event.delivery.friendly_error_message)
+  #   end
+  #
+  # Two properties of the transport shape how you should handle these:
+  #
+  # * **At-least-once.** The same `id` can arrive twice (a receiver that times
+  #   out after processing still gets retried). Key your side-effects off `id`.
+  # * **Unordered.** `delivery.delivered` can arrive before `delivery.sent`.
+  #   Branch on `event.delivery.status`, which is the state at emission time,
+  #   rather than on the order events show up in.
+  class Event
+    # @return [String] "evt_..." -- stable across retries, so it is what you
+    #   deduplicate on
+    attr_reader :id
+    # @return [String] e.g. "delivery.delivered"
+    attr_reader :type
+    # @return [Time, nil] when the event was emitted
+    attr_reader :created_at
+    # @return [Hash] the raw `data` object
+    attr_reader :data
+    # @return [Hash] the whole envelope as received
+    attr_reader :raw
+
+    def initialize(payload)
+      @raw = payload
+      @id = payload["id"]
+      @type = payload["type"]
+      @created_at = parse_time(payload["created_at"])
+      @data = payload["data"] || {}
+      # Built up front, not memoized: the instance is frozen below, matching
+      # Delivery -- an Event handed to another thread never changes underneath it.
+      @delivery = Delivery.new(@data["delivery"]) if @data["delivery"].is_a?(Hash)
+
+      freeze
+    end
+
+    # The delivery this event is about, in exactly the shape
+    # `client.deliveries.get` returns -- the server serializes both from one
+    # definition, so webhook-driven and polling code can share their handlers.
+    #
+    # @return [RelayGrid::Delivery, nil] nil for events with no delivery (ping)
+    attr_reader :delivery
+
+    # True for the test event the dashboard's "send test event" button emits.
+    def ping?
+      type == "ping"
+    end
+
+    def delivery_event?
+      type.to_s.start_with?("delivery.")
+    end
+
+    def to_h
+      raw
+    end
+
+    def inspect
+      "#<RelayGrid::Event id: #{id.inspect}, type: #{type.inspect}>"
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil? || value.to_s.empty?
+
+      Time.parse(value.to_s)
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/relaygrid/resources/deliveries.rb

@@ -44,11 +44,9 @@ module RelayGrid
       # return the delivery ids and let the browser poll `#get_all`, or subscribe
       # to the realtime channel with `RelayGrid.websocket`.
       #
-      # `failed` is not terminal here: delivery jobs retry, so a failed row can
-      # still flip to `sent` and then `delivered` inside the window. Waiting out
-      # the timeout on a genuinely failed delivery is the deliberate trade -- it
-      # mirrors the dashboard, and reporting a transient failure as final is the
-      # worse error.
+      # Returns as soon as every delivery is terminal, successful or not. A
+      # delivery the server is still retrying reads `retrying`, so `failed`
+      # here means final and there is nothing left to wait for.
       #
       # @param ids [Array<Integer>]
       # @param timeout [Numeric] seconds
@@ -65,7 +63,7 @@ module RelayGrid
 
         loop do
           deliveries = get_all(ids)
-          return deliveries if deliveries.any? && deliveries.all?(&:success?)
+          return deliveries if deliveries.any? && deliveries.all?(&:terminal?)
 
           # Never sleep past the deadline: the caller's timeout is honoured to
           # within one request, not rounded up to the next whole interval.

data/lib/relaygrid/resources/webhook_endpoints.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RelayGrid
+  module Resources
+    # Manage the HTTPS endpoint RelayGrid pushes delivery-status events to.
+    #
+    # Registering one is what replaces polling: instead of calling
+    # `wait_for_deliveries`, your app receives `delivery.*` events as they
+    # happen and verifies them with RelayGrid::Webhooks.construct_event.
+    #
+    #   endpoint = client.webhook_endpoints.create(url: "https://app.example.com/relaygrid/webhooks")
+    #   endpoint["secret"] # => "whsec_..." -- returned here and on rotate only
+    #
+    # Store that secret before you drop the response: list and show return only
+    # a preview of it.
+    #
+    # An account has **one** endpoint. `list` is still a collection for
+    # forward compatibility, but it holds at most one entry, and creating a
+    # second is a 409 -- change the URL with #update, or #delete and re-create.
+    class WebhookEndpoints
+      PATH = "/api/v1/webhook_endpoints"
+
+      def initialize(client)
+        @client = client
+      end
+
+      # @return [Array<Hash>] at most one entry
+      def list
+        Array(@client.get(PATH)["webhook_endpoints"])
+      end
+
+      # The account's endpoint, or nil when none is registered.
+      #
+      # @return [Hash, nil]
+      def current
+        list.first
+      end
+
+      # @param id [Integer]
+      # @return [Hash]
+      # @raise [RelayGrid::NotFoundError]
+      def get(id)
+        @client.get("#{PATH}/#{id}")["webhook_endpoint"]
+      end
+
+      # An endpoint receives every event type, including ones added later, so
+      # there is nothing to subscribe to -- switch on `event.type` in your
+      # receiver instead.
+      #
+      # @param url [String] an https URL on a publicly resolvable host
+      # @return [Hash] including the plaintext "secret"
+      # @raise [RelayGrid::ValidationError] the URL was rejected (not https, or
+      #   pointing at a private/loopback address)
+      # @raise [RelayGrid::APIError] HTTP 409 -- this account already has its
+      #   one endpoint
+      def create(url:)
+        @client.post(PATH, body: { webhook_endpoint: { url: url } })["webhook_endpoint"]
+      end
+
+      # @return [Hash]
+      def update(id, url: nil, active: nil)
+        attributes = {}
+        attributes[:url] = url unless url.nil?
+        attributes[:active] = active unless active.nil?
+
+        @client.patch("#{PATH}/#{id}", body: { webhook_endpoint: attributes })["webhook_endpoint"]
+      end
+
+      # @return [true]
+      def delete(id)
+        @client.delete("#{PATH}/#{id}")
+        true
+      end
+
+      # Issue a new signing secret, returned in full. The previous secret stops
+      # working at once, so deploy the new one to your receiver first.
+      #
+      # @return [Hash] including the plaintext "secret"
+      def rotate_secret(id)
+        @client.post("#{PATH}/#{id}/rotate_secret")["webhook_endpoint"]
+      end
+
+      # Clear the auto-disabled state after fixing a receiver RelayGrid gave up on.
+      #
+      # @return [Hash]
+      def reactivate(id)
+        @client.post("#{PATH}/#{id}/reactivate")["webhook_endpoint"]
+      end
+
+      # Queue a signed `ping` so you can confirm the URL and secret work before
+      # real traffic depends on them. Delivery is asynchronous -- check #attempts
+      # for the result.
+      #
+      # @return [String] the event id that was queued
+      def test(id)
+        @client.post("#{PATH}/#{id}/test")["event_id"]
+      end
+
+      # Recent dispatch attempts, newest first: response codes, errors and
+      # durations. The "why didn't my webhook arrive?" log.
+      #
+      # @return [Array<Hash>]
+      def attempts(id)
+        Array(@client.get("#{PATH}/#{id}/attempts")["attempts"])
+      end
+    end
+  end
+end

data/lib/relaygrid/send_result.rb

@@ -43,12 +43,8 @@ module RelayGrid
       deliveries.find { |delivery| delivery.channel_type == channel_type.to_s }
     end
 
-    # Poll until every delivery settles into a success state, or `timeout`
-    # seconds elapse.
-    #
-    # `failed` is not treated as terminal inside the window: delivery jobs
-    # retry, so a failed row can still flip to `sent` and then `delivered`.
-    # That mirrors the dashboard's semantics.
+    # Poll until every delivery reaches a terminal state, or `timeout` seconds
+    # elapse. A delivery the server is still retrying reads `retrying`.
     #
     # @param timeout [Numeric] seconds to keep polling
     # @param interval [Numeric] seconds between polls

data/lib/relaygrid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RelayGrid
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/relaygrid/webhooks.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+
+module RelayGrid
+  # Verification for delivery-status webhooks -- the piece you drop into your
+  # receiving controller.
+  #
+  #   class RelayGridWebhooksController < ApplicationController
+  #     skip_before_action :verify_authenticity_token
+  #
+  #     def create
+  #       event = RelayGrid::Webhooks.construct_event(
+  #         request.raw_post,
+  #         request.headers["X-RelayGrid-Signature"],
+  #         ENV.fetch("RELAYGRID_WEBHOOK_SECRET")
+  #       )
+  #
+  #       MyDeliveryTracker.handle(event)
+  #       head :ok
+  #     rescue RelayGrid::SignatureVerificationError
+  #       head :bad_request
+  #     end
+  #   end
+  #
+  # Two things are checked, and both matter. The HMAC proves the body came from
+  # RelayGrid and was not altered; the timestamp -- which is signed *with* the
+  # body, not merely sent beside it -- bounds how long a captured request stays
+  # replayable. Verify before you parse: it is the raw bytes that were signed,
+  # so re-serializing the JSON first will not verify.
+  module Webhooks
+    SIGNATURE_VERSION = "v1"
+    DIGEST = "SHA256"
+
+    # How far a webhook's timestamp may be from your clock. Five minutes
+    # matches Stripe's default: wide enough for ordinary clock skew and a slow
+    # retry, narrow enough that a captured request stops working quickly.
+    DEFAULT_TOLERANCE = 300
+
+    module_function
+
+    # @param payload [String] the raw request body, exactly as received
+    # @param signature_header [String] the X-RelayGrid-Signature header
+    # @param secret [String] the endpoint's signing secret ("whsec_...")
+    # @param tolerance [Integer, nil] seconds; nil disables the replay window
+    # @return [RelayGrid::Event]
+    # @raise [RelayGrid::SignatureVerificationError] bad signature, missing or
+    #   malformed header, or a timestamp outside the tolerance
+    def construct_event(payload, signature_header, secret, tolerance: DEFAULT_TOLERANCE)
+      verify_signature(payload, signature_header, secret, tolerance: tolerance)
+
+      data = begin
+        JSON.parse(payload.to_s)
+      rescue JSON::ParserError => e
+        raise SignatureVerificationError, "Webhook body is not valid JSON: #{e.message}"
+      end
+
+      Event.new(data)
+    end
+
+    # Same checks as construct_event, without building the event.
+    #
+    # @return [true]
+    # @raise [RelayGrid::SignatureVerificationError]
+    def verify_signature(payload, signature_header, secret, tolerance: DEFAULT_TOLERANCE)
+      raise SignatureVerificationError, "Webhook signing secret is missing" if secret.nil? || secret.empty?
+
+      timestamp, signatures = parse_header(signature_header)
+
+      if tolerance
+        age = Time.now.to_i - timestamp
+        if age.abs > tolerance
+          raise SignatureVerificationError,
+                "Webhook timestamp is outside the #{tolerance}s tolerance (off by #{age}s)"
+        end
+      end
+
+      expected = signature(payload, timestamp, secret)
+      unless signatures.any? { |candidate| secure_compare(candidate, expected) }
+        raise SignatureVerificationError, "Webhook signature does not match the expected value"
+      end
+
+      true
+    end
+
+    # The MAC of "<timestamp>.<body>", which is what the sender signed.
+    def signature(payload, timestamp, secret)
+      OpenSSL::HMAC.hexdigest(DIGEST, secret.to_s, "#{timestamp}.#{payload}")
+    end
+
+    # "t=1753722191,v1=abc..." -> [1753722191, ["abc..."]]
+    #
+    # Several v1 entries are accepted so RelayGrid can sign with an old and a
+    # new secret at once during a rotation.
+    def parse_header(signature_header)
+      raise SignatureVerificationError, "Webhook signature header is missing" if signature_header.nil?
+
+      parts = signature_header.to_s.split(",").map { |part| part.split("=", 2) }
+      pairs = parts.select { |pair| pair.length == 2 }
+
+      timestamp = pairs.find { |name, _| name.strip == "t" }&.last
+      signatures = pairs.select { |name, _| name.strip == SIGNATURE_VERSION }.map(&:last)
+
+      if timestamp.nil? || signatures.empty?
+        raise SignatureVerificationError,
+              "Webhook signature header is malformed: #{signature_header.inspect}"
+      end
+
+      [Integer(timestamp, 10), signatures]
+    rescue ArgumentError, TypeError
+      raise SignatureVerificationError,
+            "Webhook signature header carries a non-numeric timestamp: #{signature_header.inspect}"
+    end
+
+    # Constant-time comparison: a byte-by-byte `==` returns early on the first
+    # mismatch, leaking through its own timing how much of a guessed signature
+    # was correct. Written out rather than delegated so the gem doesn't depend
+    # on which OpenSSL binding version the host application happens to have.
+    def secure_compare(left, right)
+      left = left.to_s.b
+      right = right.to_s.b
+      return false unless left.bytesize == right.bytesize
+
+      result = 0
+      left.each_byte.with_index { |byte, index| result |= byte ^ right.getbyte(index) }
+      result.zero?
+    end
+  end
+end

data/lib/relaygrid.rb

@@ -4,8 +4,10 @@ require_relative "relaygrid/version"
 require_relative "relaygrid/errors"
 require_relative "relaygrid/configuration"
 require_relative "relaygrid/delivery"
+require_relative "relaygrid/event"
 require_relative "relaygrid/send_result"
 require_relative "relaygrid/client"
+require_relative "relaygrid/webhooks"
 require_relative "relaygrid/websocket_client"
 require_relative "relaygrid/resources/notifications"
 require_relative "relaygrid/resources/deliveries"
@@ -13,6 +15,7 @@ require_relative "relaygrid/resources/messages"
 require_relative "relaygrid/resources/message_templates"
 require_relative "relaygrid/resources/users"
 require_relative "relaygrid/resources/channel_tokens"
+require_relative "relaygrid/resources/webhook_endpoints"
 
 # Ruby client for the RelayGrid / RelayGrid notification API.
 #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: relaygrid
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Ali Zand
@@ -140,14 +140,17 @@ files:
 - lib/relaygrid/configuration.rb
 - lib/relaygrid/delivery.rb
 - lib/relaygrid/errors.rb
+- lib/relaygrid/event.rb
 - lib/relaygrid/resources/channel_tokens.rb
 - lib/relaygrid/resources/deliveries.rb
 - lib/relaygrid/resources/message_templates.rb
 - lib/relaygrid/resources/messages.rb
 - lib/relaygrid/resources/notifications.rb
 - lib/relaygrid/resources/users.rb
+- lib/relaygrid/resources/webhook_endpoints.rb
 - lib/relaygrid/send_result.rb
 - lib/relaygrid/version.rb
+- lib/relaygrid/webhooks.rb
 - lib/relaygrid/websocket_client.rb
 - sig/relaygrid.rbs
 homepage: https://github.com/alizand1992/relaygrid-gem