onyxcord 2.0.13 → 3.2.0

data/lib/onyxcord/internal/event_executor.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative 'async_runtime'
+
+module OnyxCord
+  module Internal
+    module EventExecutor
+      STOP = Object.new.freeze
+
+      class Inline
+        def post
+          yield
+        end
+
+        def shutdown; end
+
+        def threads
+          []
+        end
+      end
+
+      class Pool
+        attr_reader :queue
+
+        def initialize(size:, queue_size: nil)
+          raise ArgumentError, 'Pool size must be greater than zero' unless size.positive?
+
+          @size = size
+          @queue = queue_size ? SizedQueue.new(queue_size) : Queue.new
+          @closed = false
+          @workers = []
+
+          start_workers
+        end
+
+        def post(&block)
+          raise ArgumentError, 'EventExecutor::Pool#post requires a block' unless block
+          raise 'Event executor has been shut down' if @closed
+
+          @queue << block
+        end
+
+        def queue_size
+          @queue.size
+        end
+
+        def threads
+          @workers
+        end
+
+        def shutdown
+          return if @closed
+
+          @closed = true
+          @size.times { @queue << STOP }
+          @workers.each do |w|
+            w.join unless w == Thread.current
+          rescue StandardError
+            nil
+          end
+        end
+
+        private
+
+        def start_workers
+          @workers = Array.new(@size) do |index|
+            Thread.new do
+              Thread.current[:onyxcord_name] = "event-worker-#{index + 1}"
+              worker_loop
+            end
+          end
+        end
+
+        def worker_loop
+          loop do
+            job = @queue.pop
+            break if job.equal?(STOP)
+
+            job.call
+          rescue StandardError => e
+            OnyxCord::LOGGER.log_exception(e) if defined?(OnyxCord::LOGGER)
+          end
+        end
+      end
+
+      class AsyncPool
+        attr_reader :queue
+
+        def initialize(size:, queue_size: nil) # rubocop:disable Lint/UnusedMethodArgument
+          raise ArgumentError, 'Pool size must be greater than zero' unless size.positive?
+
+          @size = size
+          @queue = ::Async::Queue.new
+          @closed = false
+          @workers = []
+          start_workers
+        end
+
+        def post(&block)
+          raise ArgumentError, 'EventExecutor::AsyncPool#post requires a block' unless block
+          raise 'Event executor has been shut down' if @closed
+
+          @queue.enqueue(block)
+        end
+
+        def queue_size
+          @queue.size
+        end
+
+        def shutdown
+          return if @closed
+
+          @closed = true
+          @size.times { @queue.enqueue(STOP) }
+        end
+
+        def threads
+          []
+        end
+
+        private
+
+        def start_workers
+          @workers = Array.new(@size) do
+            AsyncRuntime.async do
+              loop do
+                job = @queue.dequeue
+                break if job.equal?(STOP)
+
+                job.call
+              rescue StandardError => e
+                OnyxCord::LOGGER.log_exception(e) if defined?(OnyxCord::LOGGER)
+              end
+            end
+          end
+        end
+      end
+
+      module_function
+
+      def build(type, workers:, queue_size: nil)
+        case type
+        when :inline
+          Inline.new
+        when :pool
+          Pool.new(size: workers, queue_size: queue_size)
+        when :async_pool
+          AsyncPool.new(size: workers, queue_size: queue_size)
+        else
+          raise ArgumentError, "Unknown event executor: #{type.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/internal/gateway/opcodes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module Internal
+    module Gateway
+      module Opcodes
+        DISPATCH = 0
+        HEARTBEAT = 1
+        IDENTIFY = 2
+        PRESENCE = 3
+        VOICE_STATE = 4
+        VOICE_PING = 5
+        RESUME = 6
+        RECONNECT = 7
+        REQUEST_MEMBERS = 8
+        INVALIDATE_SESSION = 9
+        HELLO = 10
+        HEARTBEAT_ACK = 11
+      end
+    end
+  end
+end

data/lib/onyxcord/internal/gateway/session.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module Internal
+    module Gateway
+      class Session
+        attr_reader :session_id, :resume_gateway_url
+        attr_accessor :sequence
+
+        def initialize(session_id, resume_gateway_url)
+          @session_id = session_id
+          @sequence = 0
+          @suspended = false
+          @invalid = false
+          @resume_gateway_url = resume_gateway_url
+        end
+
+        def suspend
+          @suspended = true
+        end
+
+        def suspended?
+          @suspended
+        end
+
+        def resume
+          @suspended = false
+        end
+
+        def invalidate
+          @invalid = true
+          @resume_gateway_url = nil
+        end
+
+        def invalid?
+          @invalid
+        end
+
+        def should_resume?
+          suspended? && !invalid?
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/internal/http.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'httpx'
+require 'net/http'
+require_relative 'json'
+require_relative 'upload'
+require 'securerandom'
+require 'uri'
+
+module OnyxCord
+  module Internal
+    # Modern HTTP adapter wrapping HTTPX with persistent connections, automatic
+    # retries on 502, and a response interface compatible with the rest of OnyxCord.
+    module HTTP
+      # Lightweight response wrapper so call-sites that relied on RestClient's
+      # `.body`, `.headers`, `.code` interface keep working unchanged.
+      class Response
+        # @return [String] the response body
+        attr_reader :body
+
+        # @return [Integer] the HTTP status code
+        attr_reader :code
+
+        # @return [Hash] the response headers (symbol keys, underscored)
+        attr_reader :headers
+
+        def initialize(httpx_response)
+          @raw = httpx_response
+          @body = httpx_response.body.to_s
+          @code = httpx_response.respond_to?(:status) ? httpx_response.status : httpx_response.code.to_i
+          response_headers = httpx_response.respond_to?(:headers) ? httpx_response.headers : httpx_response.to_hash
+          @headers = normalize_headers(response_headers)
+        end
+
+        def to_s
+          @body
+        end
+
+        # RestClient compatibility — some code calls `response` directly as a
+        # string (implicit to_s).
+        alias_method :to_str, :to_s
+
+        private
+
+        def normalize_headers(headers)
+          transformed = headers.to_h.transform_keys do |key|
+            key.to_s.tr('-', '_').downcase.to_sym
+          end
+          transformed.transform_values do |value|
+            value.is_a?(Array) && value.size == 1 ? value.first : value
+          end
+        end
+      end
+
+      module_function
+
+      # The shared HTTPX session with persistent connections for the current thread.
+      def session
+        Thread.current[:onyxcord_http_session] ||= HTTPX.plugin(:persistent)
+                                                        .plugin(:follow_redirects)
+                                                        .with(
+                                                          fallback_protocol: 'http/1.1',
+                                                          ssl: { alpn_protocols: ['http/1.1'] }
+                                                        )
+      end
+
+      # Reset the HTTP session (useful for tests).
+      def reset!
+        Thread.current[:onyxcord_http_session] = nil
+      end
+
+      # Perform a raw HTTP request and return a {Response}.
+      # @param type [Symbol] HTTP method (:get, :post, :put, :patch, :delete)
+      # @param url [String] The full URL.
+      # @param body [String, Hash, nil] The request body.
+      # @param headers [Hash] Request headers.
+      # @return [Response]
+      def request(type, url, body = nil, **headers)
+        http = session.with(headers: headers)
+
+        raw = case type
+              when :get
+                http.get(url)
+              when :post
+                if multipart?(body)
+                  # Multipart upload
+                  post_multipart(url, body, headers)
+                else
+                  http.post(url, body: body)
+                end
+              when :put
+                http.put(url, body: body)
+              when :patch
+                http.patch(url, body: body)
+              when :delete
+                http.delete(url)
+              else
+                raise ArgumentError, "Unknown HTTP method: #{type}"
+              end
+
+        # HTTPX returns an error response object on network failures
+        raise raw.error if raw.is_a?(HTTPX::ErrorResponse)
+
+        Response.new(raw)
+      end
+
+      def post_multipart(url, body, headers)
+        uri = URI(url)
+        boundary = "----OnyxCord#{SecureRandom.hex(12)}"
+        request = Net::HTTP::Post.new(uri)
+        headers.each { |key, value| request[key.to_s] = value }
+        request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+        request.body = multipart_body(body, boundary)
+
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+      end
+
+      def multipart_body(body, boundary)
+        output = (+'').b
+
+        multipart_parts(body).each do |part|
+          key = part[:name]
+          value = part[:value]
+          output << "--#{boundary}\r\n"
+          if part[:filename]
+            value.rewind if value.respond_to?(:rewind)
+            filename = part[:filename]
+            output << "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{filename}\"\r\n"
+            output << "Content-Type: #{part[:content_type] || multipart_content_type(filename)}\r\n\r\n"
+            output << value.read.to_s
+          else
+            output << "Content-Disposition: form-data; name=\"#{key}\"\r\n"
+            output << "\r\n"
+            output << value.to_s
+          end
+          output << "\r\n"
+        end
+
+        output << "--#{boundary}--\r\n"
+      end
+
+      def multipart_content_type(filename)
+        File.extname(filename).casecmp('.txt').zero? ? 'text/plain' : 'application/octet-stream'
+      end
+
+      def multipart?(body)
+        return true if body.is_a?(Array) && body.all? { |part| part.is_a?(Hash) && part[:name] && part.key?(:value) }
+
+        body.is_a?(Hash) && body.any? { |_, value| value.respond_to?(:read) || value.respond_to?(:path) }
+      end
+
+      def multipart_parts(body)
+        return body if body.is_a?(Array)
+
+        body.map do |key, value|
+          if value.respond_to?(:read) || value.respond_to?(:path)
+            upload = Upload.wrap(value)
+            { name: key, value: upload, filename: upload.filename, content_type: upload.content_type }
+          else
+            { name: key, value: value }
+          end
+        end
+      end
+
+      # Convenience wrappers
+      def get(url, **headers)
+        request(:get, url, nil, **headers)
+      end
+
+      def post(url, body = nil, **headers)
+        request(:post, url, body, **headers)
+      end
+
+      def put(url, body = nil, **headers)
+        request(:put, url, body, **headers)
+      end
+
+      def patch(url, body = nil, **headers)
+        request(:patch, url, body, **headers)
+      end
+
+      def delete(url, **headers)
+        request(:delete, url, nil, **headers)
+      end
+    end
+  end
+end

data/lib/onyxcord/internal/json.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+# Configure Oj in compat mode so that all stdlib JSON.parse / .to_json calls
+# are transparently accelerated. This is loaded early by the main onyxcord.rb
+# entry point so every module benefits automatically.
+module OnyxCord
+  module Internal
+    # Fast Oj-backed JSON wrapper providing compatibility with stdlib JSON methods.
+    module JSON
+      Oj.default_options = { mode: :compat, symbol_keys: false }
+
+      module_function
+
+      # Fast JSON decode using Oj via stdlib JSON compatibility.
+      # @param data [String] The JSON string to decode.
+      # @return [Hash, Array, String, Numeric, nil]
+      def decode(data, *args)
+        ::JSON.parse(data, *args)
+      end
+
+      # Fast JSON encode using Oj via stdlib JSON compatibility.
+      # @param data [Object] The object to encode as JSON.
+      # @return [String]
+      def encode(data, *args)
+        ::JSON.generate(data, *args)
+      end
+
+      # Alias parse to decode for standard library compatibility
+      def parse(data, *args)
+        ::JSON.parse(data, *args)
+      end
+
+      # Alias generate to encode for standard library compatibility
+      def generate(data, *args)
+        ::JSON.generate(data, *args)
+      end
+
+      # Alias load to decode for Oj/JSON compatibility
+      def load(data, *args)
+        ::JSON.parse(data, *args)
+      end
+
+      # Alias dump to encode for Oj/JSON compatibility
+      def dump(data, *args)
+        ::JSON.generate(data, *args)
+      end
+    end
+  end
+end

data/lib/onyxcord/internal/message_payload.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../utils/message_components'
+require_relative 'upload'
+
+module OnyxCord
+  module MessagePayload
+    MAX_ATTACHMENTS = 10
+    MAX_EMBEDS = 10
+    KEEP = :keep
+
+    module_function
+
+    def attachment_payload(attachments)
+      uploads(attachments).map.with_index { |upload, index| { id: index, filename: upload.filename } }
+    end
+
+    def multipart_body(body, attachments)
+      parts = uploads(attachments).map.with_index do |upload, index|
+        {
+          name: "files[#{index}]",
+          value: upload,
+          filename: upload.filename,
+          content_type: upload.content_type || 'application/octet-stream'
+        }
+      end
+
+      parts << { name: 'payload_json', value: body.to_json }
+    end
+
+    def validate!(content: nil, embeds: nil, components: nil, flags: nil, attachments: nil, poll: nil)
+      validate_limit!('attachments', attachments, MAX_ATTACHMENTS)
+      validate_limit!('embeds', embeds, MAX_EMBEDS)
+      validate_components_v2!(content, embeds, components, flags, poll)
+    end
+
+    def edit_body(content, embeds)
+      content_keep = content == KEEP
+      embeds_keep = embeds == KEEP
+      content_given = !content_keep && !content.nil?
+      embeds_given = !embeds_keep && !embeds.nil?
+      body = {}
+      body[:content] = content if !content_keep && (content_given || embeds_given)
+      body[:embeds] = embeds_given ? embeds : [] if !embeds_keep && (embeds_given || content_given)
+      body
+    end
+
+    def uploads(attachments)
+      Array(attachments).map { |attachment| OnyxCord::Upload.wrap(attachment) }
+    end
+
+    def validate_limit!(name, values, max)
+      return if values.nil? || Array(values).length <= max
+
+      raise ArgumentError, "#{name} cannot exceed #{max} elements"
+    end
+
+    def validate_components_v2!(content, embeds, components, flags, poll)
+      return unless components_v2?(components, flags)
+      return unless present?(content) || present?(embeds) || present?(poll)
+
+      raise ArgumentError, 'Components V2 messages cannot include content, embeds, or poll'
+    end
+
+    def components_v2?(components, flags)
+      OnyxCord::MessageComponents.components_v2?(components) ||
+        OnyxCord::MessageComponents.flag_value(flags).anybits?(OnyxCord::MessageComponents::IS_COMPONENTS_V2)
+    end
+
+    def present?(value)
+      return false if value.nil?
+      return false if value == KEEP
+      return !value.empty? if value.respond_to?(:empty?)
+
+      true
+    end
+  end
+end

data/lib/onyxcord/internal/rate_limiter/async_rest.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative '../async_runtime'
+
+module OnyxCord
+  module Internal
+    module RateLimiter
+      class AsyncRest
+        DEFAULT_ENTRY_TTL = 3600
+        DEFAULT_PRUNE_INTERVAL = 100
+
+        def initialize(clock: -> { Time.now }, entry_ttl: DEFAULT_ENTRY_TTL, prune_interval: DEFAULT_PRUNE_INTERVAL)
+          @route_buckets = {}
+          @bucket_locks = {}
+          @bucket_last_used = {}
+          @global_lock = Mutex.new
+          @clock = clock
+          @entry_ttl = entry_ttl
+          @prune_interval = prune_interval
+          @requests_since_prune = 0
+        end
+
+        def before_request(route, major_parameter)
+          wait_for(@global_lock)
+          wait_for(mutex_for(route, major_parameter))
+        end
+
+        def record_response(route, major_parameter, headers)
+          headers = normalize_headers(headers)
+          bucket = headers[:x_ratelimit_bucket]
+          key = route_key(route, major_parameter)
+          touch(key)
+
+          if bucket
+            bucket = bucket_key(bucket, major_parameter)
+            @route_buckets[key] = bucket
+            touch(bucket)
+          end
+
+          return unless headers[:x_ratelimit_remaining] == '0'
+
+          wait_seconds = headers[:x_ratelimit_reset_after].to_f
+          return unless wait_seconds.positive?
+
+          async_wait(wait_seconds, mutex_for(route, major_parameter))
+        end
+
+        def handle_rate_limit(route, major_parameter, response)
+          headers = normalize_headers(response.headers)
+          wait_seconds = retry_after(response, headers)
+
+          return unless wait_seconds.positive?
+
+          if headers[:x_ratelimit_global] == 'true' || headers[:x_ratelimit_scope] == 'global'
+            global_wait(wait_seconds)
+          else
+            async_wait(wait_seconds, mutex_for(route, major_parameter))
+          end
+        end
+
+        def stats
+          {
+            route_buckets: @route_buckets.size,
+            bucket_locks: @bucket_locks.size,
+            tracked_keys: @bucket_last_used.size
+          }
+        end
+
+        def prune!
+          return 0 unless @entry_ttl
+
+          cutoff = @clock.call - @entry_ttl
+          stale_keys = @bucket_last_used.select { |_, last_used| last_used < cutoff }.keys
+
+          stale_keys.each do |key|
+            @bucket_locks.delete(key)
+            @bucket_last_used.delete(key)
+            @route_buckets.delete(key)
+            @route_buckets.delete_if { |_, bucket_key| bucket_key == key }
+          end
+
+          @requests_since_prune = 0
+          stale_keys.length
+        end
+
+        private
+
+        def mutex_for(route, major_parameter)
+          key = resolved_key(route, major_parameter)
+          touch(key)
+          @bucket_locks[key] ||= Mutex.new
+        end
+
+        def resolved_key(route, major_parameter)
+          @route_buckets[route_key(route, major_parameter)] || route_key(route, major_parameter)
+        end
+
+        def route_key(route, major_parameter)
+          [route, major_parameter].freeze
+        end
+
+        def bucket_key(bucket, major_parameter)
+          [:bucket, bucket, major_parameter].freeze
+        end
+
+        def retry_after(response, headers)
+          body = response.respond_to?(:body) ? response.body : response.to_s
+          if body && !body.empty?
+            data = JSON.parse(body)
+            return data['retry_after'].to_f if data['retry_after']
+          end
+
+          (headers[:retry_after] || 0).to_f
+        rescue JSON::ParserError
+          (headers[:retry_after] || 0).to_f
+        end
+
+        def normalize_headers(headers)
+          headers.each_with_object({}) do |(key, value), memo|
+            memo[key.to_s.tr('-', '_').downcase.to_sym] = value.to_s
+          end
+        end
+
+        def touch(key)
+          @bucket_last_used[key] = @clock.call
+          prune_if_needed
+        end
+
+        def prune_if_needed
+          return unless @prune_interval
+
+          @requests_since_prune += 1
+          prune! if @requests_since_prune >= @prune_interval
+        end
+
+        def wait_for(mutex)
+          mutex.lock
+          mutex.unlock
+        end
+
+        def async_wait(time, mutex)
+          mutex.synchronize { AsyncRuntime.sleep(time) }
+        end
+
+        def global_wait(time)
+          async_wait(time, @global_lock)
+        end
+      end
+    end
+  end
+end