natswork-client 0.0.1

data/lib/natswork/connection.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'nats/io/client'
+require 'json'
+require 'natswork/errors'
+
+module NatsWork
+  class Connection
+    attr_reader :servers, :max_reconnect_attempts, :reconnect_time_wait, :user, :password, :connection
+
+    def initialize(options = {})
+      @servers = options[:servers] || ['nats://localhost:4222']
+      @max_reconnect_attempts = options[:max_reconnect_attempts] || 10
+      @reconnect_time_wait = options[:reconnect_time_wait] || 2
+      @user = options[:user]
+      @password = options[:password]
+      @tls = options[:tls]
+      @client = NATS::IO::Client.new
+      @connection = @client # Alias for backward compatibility
+      @connected = false
+      @jetstream_context = nil
+      @mutex = Mutex.new
+      @reconnect_callbacks = []
+      @disconnect_callbacks = []
+      @error_callbacks = []
+      @last_ping_time = nil
+      @last_error = nil
+    end
+
+    def connect
+      return true if @connected && @client.connected?
+
+      options = {
+        servers: @servers,
+        max_reconnect_attempts: @max_reconnect_attempts,
+        reconnect_time_wait: @reconnect_time_wait
+      }
+
+      options[:user] = @user if @user
+      options[:password] = @password if @password
+      options[:tls] = @tls if @tls
+
+      setup_handlers
+
+      begin
+        @client.connect(options)
+        @connected = true
+        @client.connected?
+      rescue NATS::IO::ConnectError => e
+        raise ConnectionError, "Failed to connect to NATS: #{e.message}"
+      rescue StandardError => e
+        raise ConnectionError, "Connection error: #{e.message}"
+      end
+    end
+
+    def disconnect
+      return unless @connected
+
+      @mutex.synchronize do
+        @client.close if @client.connected?
+        @connected = false
+        @jetstream_context = nil
+      end
+    end
+
+    def connected?
+      @connected && @client.connected?
+    end
+
+    def publish(subject, payload)
+      raise ConnectionError, 'Not connected to NATS' unless connected?
+
+      data = payload.is_a?(String) ? payload : JSON.generate(payload)
+      @client.publish(subject, data)
+    end
+
+    def subscribe(subject, opts = {}, &block)
+      raise ConnectionError, 'Not connected to NATS' unless connected?
+
+      wrapped_callback = proc do |msg, reply, subject, sid|
+        parsed_msg = begin
+          JSON.parse(msg, symbolize_names: true)
+        rescue JSON::ParserError
+          msg
+        end
+        block.call(parsed_msg, reply, subject, sid)
+      end
+
+      if opts[:queue]
+        @client.subscribe(subject, queue: opts[:queue], &wrapped_callback)
+      else
+        @client.subscribe(subject, &wrapped_callback)
+      end
+    end
+
+    def request(subject, payload, opts = {})
+      raise ConnectionError, 'Not connected to NATS' unless connected?
+
+      timeout = opts[:timeout] || 5
+      data = payload.is_a?(String) ? payload : JSON.generate(payload)
+
+      begin
+        response = @client.request(subject, data, timeout: timeout)
+        JSON.parse(response.data)
+      rescue NATS::IO::Timeout
+        raise TimeoutError, "Request timed out after #{timeout} seconds"
+      rescue JSON::ParserError
+        response.data
+      end
+    end
+
+    def unsubscribe(sid)
+      return unless connected?
+
+      begin
+        @client.send(:unsubscribe, sid)
+      rescue StandardError
+        # Ignore errors for invalid SIDs
+      end
+    end
+
+    def with_connection
+      connect unless connected?
+      yield(self)
+    end
+
+    def jetstream
+      raise ConnectionError, 'Not connected to NATS' unless connected?
+
+      @jetstream_context ||= @client.jetstream
+    end
+
+    def stats
+      return {} unless @client
+
+      stats = @client.stats || {}
+      stats[:last_ping_time] = @last_ping_time
+      stats[:healthy] = healthy?
+      stats[:last_error] = @last_error
+      stats
+    end
+
+    def healthy?
+      connected? && ping
+    end
+
+    def ping
+      return false unless connected?
+
+      begin
+        # Send a ping by doing a simple request to a non-existent subject with short timeout
+        @client.flush(1)
+        @last_ping_time = Time.now
+        true
+      rescue StandardError => e
+        @last_error = e.message
+        false
+      end
+    end
+
+    def on_reconnect(&block)
+      @reconnect_callbacks << block if block_given?
+    end
+
+    def on_disconnect(&block)
+      @disconnect_callbacks << block if block_given?
+    end
+
+    def on_error(&block)
+      @error_callbacks << block if block_given?
+    end
+
+    private
+
+    def setup_handlers
+      @client.on_error do |error|
+        @last_error = error.message
+        @error_callbacks.each do |cb|
+          cb.call(error)
+        rescue StandardError
+          nil
+        end
+      end
+
+      @client.on_disconnect do
+        @connected = false
+        @disconnect_callbacks.each do |cb|
+          cb.call
+        rescue StandardError
+          nil
+        end
+      end
+
+      @client.on_reconnect do
+        @connected = true
+        @jetstream_context = nil # Reset JetStream context on reconnect
+        @reconnect_callbacks.each do |cb|
+          cb.call
+        rescue StandardError
+          nil
+        end
+      end
+
+      @client.on_close do
+        @connected = false
+        @disconnect_callbacks.each do |cb|
+          cb.call
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/natswork/connection_pool.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'monitor'
+require 'timeout'
+require 'concurrent'
+require 'natswork/connection'
+require 'natswork/errors'
+
+module NatsWork
+  class PoolTimeoutError < Error; end
+  class PoolShutdownError < Error; end
+
+  class ConnectionPool
+    attr_reader :size, :timeout
+
+    def initialize(options = {})
+      @size = options[:size] || 5
+      @timeout = options[:timeout] || 5
+      @connection_options = options[:connection_options] || {}
+
+      @available = Queue.new
+      @connections = []
+      @active = Concurrent::Array.new
+      @shutdown = false
+      @mutex = Mutex.new
+      @created_count = 0
+      @waiting_count = 0
+      @shutdown_condition = ConditionVariable.new
+    end
+
+    def with_connection(&block)
+      raise PoolShutdownError, 'Pool has been shutdown' if @shutdown
+
+      conn = checkout
+      begin
+        conn.with_connection(&block)
+      ensure
+        checkin(conn)
+      end
+    end
+
+    def shutdown(timeout: 30)
+      @mutex.synchronize do
+        @shutdown = true
+
+        # Wait for active connections to return
+        deadline = Time.now + timeout
+        @shutdown_condition.wait(@mutex, 0.1) while @active.size.positive? && Time.now < deadline
+
+        # Disconnect all connections
+        @connections.each do |conn|
+          conn.disconnect
+        rescue StandardError
+          nil
+        end
+
+        @connections.clear
+        @available.clear
+      end
+    end
+
+    def available_connections
+      @available.size
+    end
+
+    def active_connections
+      @active.size
+    end
+
+    def stats
+      {
+        size: @size,
+        available: available_connections,
+        active: active_connections,
+        waiting: @waiting_count,
+        created: @created_count
+      }
+    end
+
+    def healthy?
+      !@shutdown
+    end
+
+    private
+
+    def checkout
+      raise PoolShutdownError, 'Pool has been shutdown' if @shutdown
+
+      conn = nil
+      deadline = Time.now + @timeout
+
+      begin
+        @mutex.synchronize { @waiting_count += 1 }
+
+        # First try non-blocking pop
+        begin
+          conn = @available.pop(true)
+        rescue ThreadError
+          # Queue is empty, try to create new connection
+          @mutex.synchronize do
+            conn = create_connection if @created_count < @size
+          end
+        end
+
+        # If we still don't have a connection, wait for one
+        if conn.nil?
+          remaining = deadline - Time.now
+          raise PoolTimeoutError, "Could not obtain connection within #{@timeout} seconds" if remaining <= 0
+
+          begin
+            Timeout.timeout(remaining) do
+              conn = @available.pop
+            end
+          rescue Timeout::Error
+            raise PoolTimeoutError, "Could not obtain connection within #{@timeout} seconds"
+          end
+        end
+      ensure
+        @mutex.synchronize { @waiting_count -= 1 }
+      end
+
+      @active << conn if conn
+      conn
+    end
+
+    def checkin(conn)
+      return unless conn
+
+      @active.delete(conn)
+
+      @mutex.synchronize do
+        if @shutdown
+          begin
+            conn.disconnect
+          rescue StandardError
+            nil
+          end
+        else
+          @available << conn
+        end
+        @shutdown_condition.signal
+      end
+    end
+
+    def create_connection
+      conn = NatsWork::Connection.new(@connection_options)
+      conn.connect
+      @connections << conn
+      @created_count += 1
+      conn
+    end
+  end
+end

data/lib/natswork/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module NatsWork
+  class Error < StandardError; end
+
+  class InvalidMessageError < Error; end
+
+  class ConnectionError < Error; end
+
+  class TimeoutError < Error; end
+
+  class UnknownJobError < Error; end
+
+  class JobError < Error
+    attr_reader :job_class, :job_id, :original_error
+
+    def initialize(message, job_class: nil, job_id: nil, original_error: nil)
+      super(message)
+      @job_class = job_class
+      @job_id = job_id
+      @original_error = original_error
+    end
+  end
+
+  class RetryableError < JobError; end
+
+  class FatalError < JobError; end
+end

data/lib/natswork/jetstream_manager.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'natswork/connection'
+require 'natswork/errors'
+
+module NatsWork
+  class JetStreamError < Error; end
+
+  class JetStreamManager
+    attr_reader :connection, :prefix
+
+    def initialize(connection, prefix: 'natswork')
+      @connection = connection
+      @prefix = prefix
+      @streams = {}
+      @consumers = {}
+    end
+
+    def create_stream(name, subjects: nil, **options)
+      stream_name = "#{@prefix}_#{name}".upcase
+      subjects ||= ["#{@prefix}.#{name}.*"]
+
+      # Start with minimal required config
+      config = {
+        name: stream_name,
+        subjects: subjects
+      }
+
+      js = @connection.jetstream
+      stream = js.add_stream(**config)
+      @streams[name] = stream
+      stream
+    rescue StandardError => e
+      raise JetStreamError, "Failed to create stream #{stream_name}: #{e.message}"
+    end
+
+    def delete_stream(name)
+      stream_name = "#{@prefix}_#{name}".upcase
+      js = @connection.jetstream
+      js.delete_stream(stream_name)
+      @streams.delete(name)
+      true
+    rescue StandardError => e
+      raise JetStreamError, "Failed to delete stream #{stream_name}: #{e.message}"
+    end
+
+    def get_stream(name)
+      stream_name = "#{@prefix}_#{name}".upcase
+      @streams[name] ||= begin
+        js = @connection.jetstream
+        js.stream_info(stream_name)
+      rescue StandardError
+        nil
+      end
+    end
+
+    def create_consumer(stream_name, consumer_name, **options)
+      stream_name_full = "#{@prefix}_#{stream_name}".upcase
+      consumer_name_full = "#{@prefix}_#{consumer_name}"
+
+      config = {
+        durable_name: consumer_name_full,
+        deliver_subject: options[:deliver_subject],
+        deliver_group: options[:deliver_group] || consumer_name_full,
+        ack_policy: options[:ack_policy] || :explicit,
+        ack_wait: options[:ack_wait] || 30_000_000_000, # 30 seconds in nanoseconds
+        max_deliver: options[:max_deliver] || 3,
+        filter_subject: options[:filter_subject],
+        replay_policy: options[:replay_policy] || :instant,
+        deliver_policy: options[:deliver_policy] || :all,
+        max_ack_pending: options[:max_ack_pending] || 1000
+      }
+
+      js = @connection.jetstream
+      consumer = js.add_consumer(stream_name_full, config)
+
+      consumer_key = "#{stream_name}:#{consumer_name}"
+      @consumers[consumer_key] = consumer
+      consumer
+    rescue StandardError => e
+      raise JetStreamError, "Failed to create consumer #{consumer_name_full}: #{e.message}"
+    end
+
+    def delete_consumer(stream_name, consumer_name)
+      stream_name_full = "#{@prefix}_#{stream_name}".upcase
+      consumer_name_full = "#{@prefix}_#{consumer_name}"
+
+      js = @connection.jetstream
+      js.delete_consumer(stream_name_full, consumer_name_full)
+
+      consumer_key = "#{stream_name}:#{consumer_name}"
+      @consumers.delete(consumer_key)
+      true
+    rescue StandardError => e
+      raise JetStreamError, "Failed to delete consumer: #{e.message}"
+    end
+
+    def subscribe(stream_name, consumer_name, &block)
+      get_or_create_consumer(stream_name, consumer_name)
+
+      js = @connection.jetstream
+      js.subscribe(
+        nil,
+        durable: "#{@prefix}_#{consumer_name}",
+        stream: "#{@prefix}_#{stream_name}".upcase,
+        manual_ack: true
+      ) do |msg|
+        wrapped_msg = JetStreamMessage.new(msg, js)
+        block.call(wrapped_msg)
+      end
+    rescue StandardError => e
+      raise JetStreamError, "Failed to subscribe: #{e.message}"
+    end
+
+    def publish(subject, payload, **options)
+      js = @connection.jetstream
+
+      data = payload.is_a?(String) ? payload : JSON.generate(payload)
+
+      # Build options for publish
+      publish_opts = {}
+      publish_opts[:header] = {} unless options.empty?
+      publish_opts[:header]['Nats-Msg-Id'] = options[:msg_id] if options[:msg_id]
+      publish_opts[:timeout] = options[:timeout] if options[:timeout]
+
+      # nats-pure expects (subject, payload) or (subject, payload, opts)
+      ack = if publish_opts.empty?
+              js.publish(subject, data)
+            else
+              js.publish(subject, data, **publish_opts)
+            end
+
+      {
+        stream: ack.stream,
+        seq: ack.seq,
+        duplicate: ack.duplicate || false
+      }
+    rescue StandardError => e
+      raise JetStreamError, "Failed to publish to JetStream: #{e.message}"
+    end
+
+    def pull_subscribe(stream_name, consumer_name, batch: 1, timeout: 5)
+      stream_name_full = "#{@prefix}_#{stream_name}".upcase
+      consumer_name_full = "#{@prefix}_#{consumer_name}"
+
+      js = @connection.jetstream
+
+      subscription = js.pull_subscribe(
+        nil,
+        durable: consumer_name_full,
+        stream: stream_name_full
+      )
+
+      messages = []
+      subscription.fetch(batch, timeout: timeout) do |msg|
+        messages << JetStreamMessage.new(msg, js)
+      end
+
+      messages
+    rescue StandardError => e
+      raise JetStreamError, "Failed to pull messages: #{e.message}"
+    end
+
+    private
+
+    def get_or_create_consumer(stream_name, consumer_name)
+      consumer_key = "#{stream_name}:#{consumer_name}"
+      @consumers[consumer_key] || create_consumer(stream_name, consumer_name)
+    end
+  end
+
+  class JetStreamMessage
+    attr_reader :data, :subject, :reply, :headers, :metadata
+
+    def initialize(nats_msg, js_context)
+      @nats_msg = nats_msg
+      @js_context = js_context
+      @data = parse_data(nats_msg.data)
+      @subject = nats_msg.subject
+      @reply = nats_msg.reply
+      @headers = nats_msg.headers if nats_msg.respond_to?(:headers)
+      @metadata = extract_metadata
+      @acked = false
+    end
+
+    def ack
+      return if @acked
+
+      @nats_msg.ack
+      @acked = true
+    end
+
+    def nak(delay: nil)
+      return if @acked
+
+      if delay
+        @nats_msg.nak(delay: delay)
+      else
+        @nats_msg.nak
+      end
+      @acked = true
+    end
+
+    def in_progress
+      @nats_msg.in_progress
+    end
+
+    def term
+      return if @acked
+
+      @nats_msg.term
+      @acked = true
+    end
+
+    def acked?
+      @acked
+    end
+
+    private
+
+    def parse_data(data)
+      JSON.parse(data)
+    rescue JSON::ParserError
+      data
+    end
+
+    def extract_metadata
+      return {} unless @nats_msg.respond_to?(:metadata)
+
+      meta = @nats_msg.metadata
+      {
+        sequence: meta.sequence,
+        num_delivered: meta.num_delivered,
+        num_pending: meta.num_pending,
+        timestamp: meta.timestamp,
+        stream: meta.stream,
+        consumer: meta.consumer
+      }
+    rescue StandardError
+      {}
+    end
+  end
+end