hookbridge 1.0.0 → 1.4.0

data/lib/hookbridge/types.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+require "date"
 require "time"
 
 module HookBridge
-  # Message status constants
   module MessageStatus
     QUEUED = "queued"
     DELIVERING = "delivering"
@@ -14,7 +14,13 @@ module HookBridge
     ALL = [QUEUED, DELIVERING, SUCCEEDED, PENDING_RETRY, FAILED_PERMANENT].freeze
   end
 
-  # API key mode constants
+  module ReplayableMessageStatus
+    FAILED_PERMANENT = "failed_permanent"
+    PENDING_RETRY = "pending_retry"
+
+    ALL = [FAILED_PERMANENT, PENDING_RETRY].freeze
+  end
+
   module APIKeyMode
     LIVE = "live"
     TEST = "test"
@@ -22,7 +28,6 @@ module HookBridge
     ALL = [LIVE, TEST].freeze
   end
 
-  # Metrics time window constants
   module MetricsWindow
     ONE_HOUR = "1h"
     TWENTY_FOUR_HOURS = "24h"
@@ -32,324 +37,353 @@ module HookBridge
     ALL = [ONE_HOUR, TWENTY_FOUR_HOURS, SEVEN_DAYS, THIRTY_DAYS].freeze
   end
 
-  # Full message details
-  class Message
-    attr_reader :id, :status, :project_id, :endpoint_id, :attempt_count, :replay_count,
-                :payload_sha256, :content_type, :size_bytes, :idempotency_key,
-                :next_attempt_at, :last_error, :response_status, :response_latency_ms,
-                :created_at, :updated_at
-
-    def initialize(data)
-      @id = data["id"]
-      @status = data["status"]
-      @project_id = data["project_id"]
-      @endpoint_id = data["endpoint_id"]
-      @attempt_count = data["attempt_count"]
-      @replay_count = data["replay_count"]
-      @payload_sha256 = data["payload_sha256"]
-      @content_type = data["content_type"]
-      @size_bytes = data["size_bytes"]
-      @idempotency_key = data["idempotency_key"]
-      @next_attempt_at = parse_time(data["next_attempt_at"])
-      @last_error = data["last_error"]
-      @response_status = data["response_status"]
-      @response_latency_ms = data["response_latency_ms"]
-      @created_at = parse_time(data["created_at"])
-      @updated_at = parse_time(data["updated_at"])
+  class BaseModel
+    def initialize(data = {}, time_fields: [], date_fields: [])
+      @attributes = {}
+      (data || {}).each do |key, value|
+        @attributes[key.to_s] = convert_value(key.to_s, value, time_fields, date_fields)
+      end
     end
 
     def to_h
-      {
-        id: @id,
-        status: @status,
-        project_id: @project_id,
-        endpoint_id: @endpoint_id,
-        attempt_count: @attempt_count,
-        replay_count: @replay_count,
-        payload_sha256: @payload_sha256,
-        content_type: @content_type,
-        size_bytes: @size_bytes,
-        idempotency_key: @idempotency_key,
-        next_attempt_at: @next_attempt_at,
-        last_error: @last_error,
-        response_status: @response_status,
-        response_latency_ms: @response_latency_ms,
-        created_at: @created_at,
-        updated_at: @updated_at
-      }
+      @attributes.transform_keys(&:to_sym)
+    end
+
+    def method_missing(name, *args, &block)
+      return super unless args.empty? && block.nil?
+
+      key = name.to_s
+      return @attributes[key] if @attributes.key?(key)
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @attributes.key?(name.to_s) || super
     end
 
     private
 
-    def parse_time(value)
+    def convert_value(key, value, time_fields, date_fields)
       return nil if value.nil?
+      return Time.parse(value) if time_fields.include?(key)
+      return Date.parse(value) if date_fields.include?(key)
 
-      Time.parse(value)
+      value
     end
   end
 
-  # Lighter message summary for logs
-  class MessageSummary
-    attr_reader :message_id, :endpoint, :status, :attempt_count, :created_at,
-                :delivered_at, :response_status, :response_latency_ms, :last_error
+  class Message < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[next_attempt_at created_at updated_at])
+    end
+  end
 
+  class MessageSummary < BaseModel
     def initialize(data)
-      @message_id = data["message_id"]
-      @endpoint = data["endpoint"]
-      @status = data["status"]
-      @attempt_count = data["attempt_count"]
-      @created_at = parse_time(data["created_at"])
-      @delivered_at = parse_time(data["delivered_at"])
-      @response_status = data["response_status"]
-      @response_latency_ms = data["response_latency_ms"]
-      @last_error = data["last_error"]
+      super(data, time_fields: %w[created_at delivered_at next_attempt_at])
     end
+  end
 
-    def to_h
-      {
-        message_id: @message_id,
-        endpoint: @endpoint,
-        status: @status,
-        attempt_count: @attempt_count,
-        created_at: @created_at,
-        delivered_at: @delivered_at,
-        response_status: @response_status,
-        response_latency_ms: @response_latency_ms,
-        last_error: @last_error
-      }
+  class SendResponse < BaseModel
+  end
+
+  class ReplayResponse < BaseModel
+  end
+
+  class LogsResponse
+    attr_reader :messages, :has_more, :next_cursor
+
+    def initialize(data)
+      @messages = ((data["data"] || data["messages"] || data) || []).map { |entry| MessageSummary.new(entry) }
+      @has_more = data["has_more"] || false
+      @next_cursor = data["next_cursor"]
     end
+  end
 
-    private
+  class Metrics < BaseModel
+  end
 
-    def parse_time(value)
-      return nil if value.nil?
+  class InboundMetrics < BaseModel
+  end
 
-      Time.parse(value)
+  class DLQMessage < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[failed_at])
     end
   end
 
-  # Send webhook response
-  class SendResponse
-    attr_reader :message_id, :status
+  class DLQResponse
+    attr_reader :messages, :has_more, :next_cursor
 
     def initialize(data)
-      @message_id = data["message_id"]
-      @status = data["status"]
+      messages = data.dig("data", "messages") || data["messages"] || data
+      @messages = (messages || []).map { |entry| MessageSummary.new(entry) }
+      @has_more = data.dig("data", "has_more") || data["has_more"] || false
+      @next_cursor = data.dig("data", "next_cursor") || data["next_cursor"]
     end
+  end
 
-    def to_h
-      { message_id: @message_id, status: @status }
+  class APIKey < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at last_used_at])
+    end
+
+    def id
+      key_id
+    end
+
+    def name
+      label
     end
   end
 
-  # Replay response
-  class ReplayResponse
-    attr_reader :message_id, :status, :attempt_count
+  class APIKeysResponse
+    attr_reader :keys
 
     def initialize(data)
-      @message_id = data["message_id"]
-      @status = data["status"]
-      @attempt_count = data["attempt_count"]
+      @keys = (data["data"] || data || []).map { |entry| APIKey.new(entry) }
     end
+  end
 
-    def to_h
-      { message_id: @message_id, status: @status, attempt_count: @attempt_count }
+  class APIKeyCreated < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at])
+    end
+
+    def id
+      key_id
+    end
+
+    def name
+      label
     end
   end
 
-  # Paginated list of log entries
-  class LogsResponse
-    attr_reader :messages, :has_more, :next_cursor
+  class CreateEndpointResponse < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at])
+    end
+  end
+
+  class Endpoint < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at updated_at])
+    end
+  end
 
+  class EndpointSummary < BaseModel
     def initialize(data)
-      # data is an array directly, pagination info is at top level
-      messages_data = data["data"] || data
-      messages_data = [] unless messages_data.is_a?(Array)
-      @messages = messages_data.map { |m| MessageSummary.new(m) }
+      super(data, time_fields: %w[created_at])
+    end
+  end
+
+  class ListEndpointsResponse
+    attr_reader :endpoints, :has_more, :next_cursor
+
+    def initialize(data)
+      @endpoints = (data["data"] || data || []).map { |entry| EndpointSummary.new(entry) }
       @has_more = data["has_more"] || false
       @next_cursor = data["next_cursor"]
     end
+  end
 
-    def to_h
-      {
-        messages: @messages.map(&:to_h),
-        has_more: @has_more,
-        next_cursor: @next_cursor
-      }
+  class RotateSecretResponse < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at])
     end
   end
 
-  # Delivery metrics
-  class Metrics
-    attr_reader :window, :total_messages, :succeeded, :failed, :retries,
-                :success_rate, :avg_latency_ms
+  class SigningKey < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at])
+    end
+  end
+
+  class ReplayAllMessagesResponse < BaseModel
+  end
+
+  class ReplayBatchResult < BaseModel
+  end
+
+  class ReplayBatchMessagesResponse
+    attr_reader :replayed, :failed, :stuck, :results
 
     def initialize(data)
-      @window = data["window"]
-      @total_messages = data["total_messages"]
-      @succeeded = data["succeeded"]
+      @replayed = data["replayed"]
       @failed = data["failed"]
-      @retries = data["retries"]
-      @success_rate = data["success_rate"]
-      @avg_latency_ms = data["avg_latency_ms"]
+      @stuck = data["stuck"]
+      @results = (data["results"] || []).map { |entry| ReplayBatchResult.new(entry) }
     end
+  end
 
-    def to_h
-      {
-        window: @window,
-        total_messages: @total_messages,
-        succeeded: @succeeded,
-        failed: @failed,
-        retries: @retries,
-        success_rate: @success_rate,
-        avg_latency_ms: @avg_latency_ms
-      }
+  class Project < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at])
     end
   end
 
-  # Dead Letter Queue message
-  class DLQMessage
-    attr_reader :message_id, :endpoint, :failed_at, :reason, :attempt_count
+  class CheckoutSession < BaseModel
+  end
 
+  class PortalSession < BaseModel
+  end
+
+  class UsageHistoryRow < BaseModel
     def initialize(data)
-      @message_id = data["message_id"]
-      @endpoint = data["endpoint"]
-      @failed_at = parse_time(data["failed_at"])
-      @reason = data["reason"]
-      @attempt_count = data["attempt_count"]
+      super(data, date_fields: %w[period_start period_end])
     end
+  end
 
-    def to_h
-      {
-        message_id: @message_id,
-        endpoint: @endpoint,
-        failed_at: @failed_at,
-        reason: @reason,
-        attempt_count: @attempt_count
-      }
+  class UsageHistoryResponse
+    attr_reader :rows, :total, :limit, :offset, :has_more
+
+    def initialize(data, meta)
+      @rows = (data || []).map { |entry| UsageHistoryRow.new(entry) }
+      @total = meta["total"]
+      @limit = meta["limit"]
+      @offset = meta["offset"]
+      @has_more = meta["has_more"]
     end
+  end
 
-    private
+  class InvoiceLine < BaseModel
+  end
 
-    def parse_time(value)
-      return nil if value.nil?
+  class Invoice < BaseModel
+    attr_reader :lines
 
-      Time.parse(value)
+    def initialize(data)
+      super(data, time_fields: %w[period_start period_end created])
+      @lines = (data["lines"] || []).map { |entry| InvoiceLine.new(entry) }
     end
   end
 
-  # Paginated list of DLQ messages
-  class DLQResponse
-    attr_reader :messages, :has_more, :next_cursor
+  class InvoicesResponse
+    attr_reader :invoices, :has_more
 
-    def initialize(data)
-      # DLQ response: data can be { messages: [...] } or have messages at top level
-      messages_data = if data.is_a?(Hash) && data["data"].is_a?(Hash)
-                        data.dig("data", "messages") || []
-                      elsif data.is_a?(Hash) && data["messages"]
-                        data["messages"]
-                      elsif data.is_a?(Array)
-                        data
-                      else
-                        []
-                      end
-      @messages = messages_data.map { |m| MessageSummary.new(m) }
-      @has_more = data["has_more"] || false
-      @next_cursor = data["next_cursor"]
+    def initialize(data, meta)
+      @invoices = (data || []).map { |entry| Invoice.new(entry) }
+      @has_more = meta["has_more"]
     end
+  end
 
-    def to_h
-      {
-        messages: @messages.map(&:to_h),
-        has_more: @has_more,
-        next_cursor: @next_cursor
-      }
+  class TimeSeriesBucket < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[timestamp])
     end
   end
 
-  # API key information
-  class APIKey
-    attr_reader :key_id, :label, :prefix, :created_at, :last_used_at
-
-    # Aliases for backwards compatibility
-    alias id key_id
-    alias name label
+  class TimeSeriesMetrics
+    attr_reader :window, :buckets
 
     def initialize(data)
-      @key_id = data["key_id"]
-      @label = data["label"]
-      @prefix = data["prefix"]
-      @created_at = parse_time(data["created_at"])
-      @last_used_at = parse_time(data["last_used_at"])
+      @window = data["window"]
+      @buckets = (data["buckets"] || []).map { |entry| TimeSeriesBucket.new(entry) }
     end
+  end
 
-    def to_h
-      {
-        key_id: @key_id,
-        label: @label,
-        prefix: @prefix,
-        created_at: @created_at,
-        last_used_at: @last_used_at
-      }
+  class SubscriptionLimits < BaseModel
+  end
+
+  class SubscriptionUsage < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[period_start period_end])
     end
+  end
 
-    private
+  class Subscription
+    attr_reader :plan, :status, :limits, :usage, :cancel_at_period_end, :current_period_end
 
-    def parse_time(value)
-      return nil if value.nil?
+    def initialize(data)
+      @plan = data["plan"]
+      @status = data["status"]
+      @limits = SubscriptionLimits.new(data["limits"] || {})
+      @usage = SubscriptionUsage.new(data["usage"] || {})
+      @cancel_at_period_end = data["cancel_at_period_end"]
+      @current_period_end = data["current_period_end"] ? Time.parse(data["current_period_end"]) : nil
+    end
+  end
 
-      Time.parse(value)
+  class CreateInboundEndpointResponse < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at])
     end
   end
 
-  # API key creation response (includes full key)
-  class APIKeyCreated
-    attr_reader :key_id, :label, :key, :prefix, :created_at
+  class InboundEndpoint < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at updated_at])
+    end
+  end
 
-    # Aliases for backwards compatibility
-    alias id key_id
-    alias name label
+  class InboundEndpointSummary < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[created_at])
+    end
+  end
+
+  class ListInboundEndpointsResponse
+    attr_reader :endpoints, :has_more, :next_cursor
 
     def initialize(data)
-      @key_id = data["key_id"]
-      @label = data["label"]
-      @key = data["key"]
-      @prefix = data["prefix"]
-      @created_at = parse_time(data["created_at"])
+      @endpoints = (data["data"] || data || []).map { |entry| InboundEndpointSummary.new(entry) }
+      @has_more = data["has_more"] || false
+      @next_cursor = data["next_cursor"]
     end
+  end
 
-    def to_h
-      {
-        key_id: @key_id,
-        label: @label,
-        key: @key,
-        prefix: @prefix,
-        created_at: @created_at
-      }
+  class UpdateResult < BaseModel
+  end
+
+  class DeleteResult < BaseModel
+  end
+
+  class PauseState < BaseModel
+  end
+
+  class InboundLogEntry < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[received_at delivered_at])
     end
+  end
 
-    private
+  class InboundLogsResponse
+    attr_reader :entries, :has_more, :next_cursor
 
-    def parse_time(value)
-      return nil if value.nil?
+    def initialize(data)
+      @entries = (data["data"] || data || []).map { |entry| InboundLogEntry.new(entry) }
+      @has_more = data["has_more"] || false
+      @next_cursor = data["next_cursor"]
+    end
+  end
 
-      Time.parse(value)
+  class InboundRejection < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[received_at])
     end
   end
 
-  # List of API keys
-  class APIKeysResponse
-    attr_reader :keys
+  class InboundRejectionsResponse
+    attr_reader :entries, :has_more, :next_cursor
 
     def initialize(data)
-      # data is an array directly
-      keys_data = data.is_a?(Array) ? data : (data["data"] || data["keys"] || [])
-      keys_data = [] unless keys_data.is_a?(Array)
-      @keys = keys_data.map { |k| APIKey.new(k) }
+      @entries = (data["data"] || data || []).map { |entry| InboundRejection.new(entry) }
+      @has_more = data["has_more"] || false
+      @next_cursor = data["next_cursor"]
     end
+  end
 
-    def to_h
-      { keys: @keys.map(&:to_h) }
+  class ExportRecord < BaseModel
+    def initialize(data)
+      super(data, time_fields: %w[
+        filter_start_time
+        filter_end_time
+        started_at
+        completed_at
+        expires_at
+        created_at
+      ])
     end
   end
 end

data/lib/hookbridge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HookBridge
-  VERSION = "1.0.0"
+  VERSION = "1.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hookbridge
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.4.0
 platform: ruby
 authors:
 - HookBridge
@@ -180,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Ruby SDK for HookBridge - Guaranteed webhook delivery
 test_files: []