tina4ruby 3.10.75 → 3.10.83

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46b70ee5c1e5fb119b04afdd515d32ecbabe757871929f0f9ec9557a99869c6c
-  data.tar.gz: 932aee6552f3d94e1b69f03631ef1bae11cf88005465565b2c16bc09b997962a
+  metadata.gz: e7f1721eaefd19400dedcfdb298a6af42772aa824b9663a17d79bced2169161b
+  data.tar.gz: a712e6a50ea1ece57a4e4bc9e0e49c49dcb0f5e5c56471c1da26bd4f65c42d79
 SHA512:
-  metadata.gz: a885f897b4e6e9bac9be3871f86071c7a6dd3a100cc110dacc69b8cc29eef86000a9f92b90129c5d22f54b7d934f66d7f8a8746763b4e214ea85827f884c8c2d
-  data.tar.gz: ab11c9414db7fc6561fb572af1c29d47713cbc00b3cc2acc17f0d3673032e8843276b799d37526732a5281ede5a409a8ab7065361ac8e50a645934762cef3a2e
+  metadata.gz: 8f50ab9dbaf48c592766f8b13debe1086e7288184a69849346fae318aa270a275c28fb28399eac9a834ba3c18fb884babefc8d1f860b9326c06fdba3623b4a43
+  data.tar.gz: ab1063c1b9402c3445ee4d75fdf98eab9342560e3d1689085879a48309fbe3a9761a0ee1759f517ae0641b82f46f801b6585244f45aadd83f7dbdddfd4c54f03

data/lib/tina4/auth.rb

@@ -12,7 +12,7 @@ module Tina4
       def setup(root_dir = Dir.pwd)
         @keys_dir = File.join(root_dir, KEYS_DIR)
         FileUtils.mkdir_p(@keys_dir)
-        ensure_keys unless use_hmac?
+        ensure_keys
       end
 
       # ── HS256 helpers (stdlib only, no gem) ──────────────────────
@@ -258,8 +258,6 @@ module Tina4
       private
 
       def ensure_keys
-        return if use_hmac?
-
         @keys_dir ||= File.join(Dir.pwd, KEYS_DIR)
         FileUtils.mkdir_p(@keys_dir)
         unless File.exist?(private_key_path) && File.exist?(public_key_path)

data/lib/tina4/auto_crud.rb

@@ -97,7 +97,7 @@ module Tina4
         Tina4::Router.add_route("GET", "#{prefix}/#{table}/{id}", proc { |req, res|
           begin
             id = req.params["id"]
-            record = model_class.find(id.to_i)
+            record = model_class.find_by_id(id.to_i)
             if record
               res.json({ data: record.to_h })
             else
@@ -140,7 +140,7 @@ module Tina4
         Tina4::Router.add_route("PUT", "#{prefix}/#{table}/{id}", proc { |req, res|
           begin
             id = req.params["id"]
-            record = model_class.find(id.to_i)
+            record = model_class.find_by_id(id.to_i)
             unless record
               next res.json({ error: "Not found" }, status: 404)
             end
@@ -178,7 +178,7 @@ module Tina4
         Tina4::Router.add_route("DELETE", "#{prefix}/#{table}/{id}", proc { |req, res|
           begin
             id = req.params["id"]
-            record = model_class.find(id.to_i)
+            record = model_class.find_by_id(id.to_i)
             unless record
               next res.json({ error: "Not found" }, status: 404)
             end

data/lib/tina4/dev_admin.rb

@@ -631,16 +631,12 @@ module Tina4
 
           # Execute all statements (single write or multi-statement batch)
           total_affected = 0
-          db.start_transaction if db.respond_to?(:start_transaction)
-          begin
-            statements.each do |stmt|
-              result = db.execute(stmt)
-              total_affected += (result.respond_to?(:affected_rows) ? result.affected_rows : 0)
+          statements.each do |stmt|
+            result = db.execute(stmt)
+            if result == false
+              return { error: db.get_error || "Statement failed: #{stmt}" }
             end
-            db.commit if db.respond_to?(:commit)
-          rescue => e
-            db.rollback if db.respond_to?(:rollback)
-            return { error: e.message }
+            total_affected += (result.respond_to?(:affected_rows) ? result.affected_rows : 0)
           end
 
           { affected: total_affected, success: true }

data/lib/tina4/graphql.rb

@@ -130,7 +130,7 @@ module Tina4
       add_query(table_lower, type: type_name,
                 args: { pk_field => { type: "ID!" } },
                 description: "Fetch a single #{model_name} by #{pk_field}") do |_root, args, _ctx|
-        record = klass.find(args[pk_field])
+        record = klass.find_by_id(args[pk_field])
         record&.to_hash
       end
 
@@ -158,7 +158,7 @@ module Tina4
       add_mutation("update#{model_name}", type: type_name,
                    args: { pk_field => { type: "ID!" }, "input" => { type: "#{type_name}Input!" } },
                    description: "Update an existing #{model_name}") do |_root, args, _ctx|
-        record = klass.find(args[pk_field])
+        record = klass.find_by_id(args[pk_field])
         return nil unless record
         (args["input"] || {}).each { |k, v| record.send(:"#{k}=", v) if record.respond_to?(:"#{k}=") }
         record.save
@@ -169,7 +169,7 @@ module Tina4
       add_mutation("delete#{model_name}", type: "Boolean",
                    args: { pk_field => { type: "ID!" } },
                    description: "Delete a #{model_name} by #{pk_field}") do |_root, args, _ctx|
-        record = klass.find(args[pk_field])
+        record = klass.find_by_id(args[pk_field])
         return false unless record
         record.delete
         true
@@ -769,7 +769,7 @@ module Tina4
     end
 
     # Return schema as GraphQL SDL string.
-    def schema
+    def schema_sdl
       sdl = ""
       @schema.types.each do |name, type_obj|
         sdl += "type #{name} {\n"

data/lib/tina4/job.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+require "json"
+require "securerandom"
+
+module Tina4
+  class Job
+    attr_reader :id, :topic, :payload, :created_at, :attempts, :priority, :available_at
+    attr_accessor :status
+
+    def initialize(topic:, payload:, id: nil, priority: 0, available_at: nil, attempts: 0)
+      @id = id || SecureRandom.uuid
+      @topic = topic
+      @payload = payload
+      @created_at = Time.now
+      @attempts = attempts
+      @priority = priority
+      @available_at = available_at
+      @status = :pending
+    end
+
+    # Re-queue this message with incremented attempts.
+    # Delegates to the queue's backend via the queue reference.
+    def retry(queue:, delay_seconds: 0)
+      @attempts += 1
+      @status = :pending
+      @available_at = delay_seconds > 0 ? Time.now + delay_seconds : nil
+      queue.backend.enqueue(self)
+      self
+    end
+
+    def to_array
+      [@id, @topic, @payload, @priority, @attempts]
+    end
+
+    def to_hash
+      h = {
+        id: @id,
+        topic: @topic,
+        payload: @payload,
+        created_at: @created_at.iso8601,
+        attempts: @attempts,
+        status: @status,
+        priority: @priority
+      }
+      h[:available_at] = @available_at.iso8601 if @available_at
+      h
+    end
+
+    def to_json(*_args)
+      JSON.generate(to_hash)
+    end
+
+    def increment_attempts!
+      @attempts += 1
+    end
+
+    # Mark this job as completed.
+    def complete
+      @status = :completed
+    end
+
+    # Mark this job as failed with a reason.
+    def fail(reason = "")
+      @status = :failed
+      @error = reason
+      @attempts += 1
+    end
+
+    # Reject this job with a reason. Alias for fail().
+    def reject(reason = "")
+      fail(reason)
+    end
+
+    attr_reader :error
+  end
+end

data/lib/tina4/migration.rb

@@ -288,7 +288,10 @@ module Tina4
           Tina4::Log.info("Migration #{File.basename(file)}: #{skip_reason}")
           next
         end
-        @db.execute(stmt)
+        result = @db.execute(stmt)
+        if result == false
+          raise RuntimeError, @db.get_error || "SQL execution failed: #{stmt}"
+        end
       end
     end
 

data/lib/tina4/orm.rb

@@ -61,6 +61,18 @@ module Tina4
         @auto_map = val
       end
 
+      # Auto-CRUD flag: when set to true, registers this model for CRUD route generation
+      def auto_crud
+        @auto_crud || false
+      end
+
+      def auto_crud=(val)
+        @auto_crud = val
+        if val
+          Tina4::AutoCrud.register(self) if defined?(Tina4::AutoCrud)
+        end
+      end
+
       # Relationship definitions
       def relationship_definitions
         @relationship_definitions ||= {}
@@ -115,27 +127,42 @@ module Tina4
         QueryBuilder.from(table_name, db: db)
       end
 
-      def find(id_or_filter = nil, filter = nil, **kwargs)
-        include_list = kwargs.delete(:include)
-
-        # find(id) — find by primary key
-        # find(filter_hash) — find by criteria
-        # find(name: "Alice") — keyword args as filter hash
-        result = if id_or_filter.is_a?(Hash)
-          find_by_filter(id_or_filter)
-        elsif filter.is_a?(Hash)
-          find_by_filter(filter)
-        elsif !kwargs.empty?
-          find_by_filter(kwargs)
-        else
-          find_by_id(id_or_filter)
+      # Find records by filter dict. Always returns an array.
+      #
+      # Usage:
+      #   User.find(name: "Alice")                  → [User, ...]
+      #   User.find({age: 18}, limit: 10)           → [User, ...]
+      #   User.find(order_by: "name ASC")            → [User, ...]
+      #   User.find                                  → all records
+      #
+      # Use find_by_id(id) for single-record primary key lookup.
+      def find(filter = {}, limit: 100, offset: 0, order_by: nil, include: nil, **extra_filter)
+        # Integer or string-digit argument → primary key lookup (returns single record or nil)
+        return find_by_id(filter) if filter.is_a?(Integer)
+
+        # Merge keyword-style filters: find(name: "Alice") and find({name: "Alice"}) both work
+        filter = filter.merge(extra_filter) unless extra_filter.empty?
+        conditions = []
+        params = []
+
+        filter.each do |key, value|
+          col = field_mapping[key.to_s] || key
+          conditions << "#{col} = ?"
+          params << value
         end
 
-        if include_list && result
-          instances = result.is_a?(Array) ? result : [result]
-          eager_load(instances, include_list)
+        if soft_delete
+          conditions << "(#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0)"
         end
-        result
+
+        sql = "SELECT * FROM #{table_name}"
+        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
+        sql += " ORDER BY #{order_by}" if order_by
+
+        results = db.fetch(sql, params, limit: limit, offset: offset)
+        instances = results.map { |row| from_hash(row) }
+        eager_load(instances, include) if include
+        instances
       end
 
       # Eager load relationships for a collection of instances (prevents N+1).
@@ -343,15 +370,7 @@ module Tina4
         instance
       end
 
-      private
-
-      def auto_discover_db
-        url = ENV["DATABASE_URL"]
-        return nil unless url
-        Tina4.database = Tina4::Database.new(url, username: ENV.fetch("DATABASE_USERNAME", ""), password: ENV.fetch("DATABASE_PASSWORD", ""))
-        Tina4.database
-      end
-
+      # Find a single record by primary key. Returns instance or nil.
       def find_by_id(id)
         pk = primary_key_field || :id
         sql = "SELECT * FROM #{table_name} WHERE #{pk} = ?"
@@ -361,6 +380,15 @@ module Tina4
         select_one(sql, [id])
       end
 
+      private
+
+      def auto_discover_db
+        url = ENV["DATABASE_URL"]
+        return nil unless url
+        Tina4.database = Tina4::Database.new(url, username: ENV.fetch("DATABASE_USERNAME", ""), password: ENV.fetch("DATABASE_PASSWORD", ""))
+        Tina4.database
+      end
+
       def find_by_filter(filter)
         where_parts = filter.keys.map { |k| "#{k} = ?" }
         sql = "SELECT * FROM #{table_name} WHERE #{where_parts.join(' AND ')}"
@@ -414,7 +442,7 @@ module Tina4
           @persisted = true
         end
       end
-      self
+      true
     rescue => e
       @errors << e.message
       false
@@ -483,8 +511,29 @@ module Tina4
 
     # Load a record into this instance via select_one.
     # Returns true if found and loaded, false otherwise.
-    def load(sql, params = [], include: nil)
+    # Load a record into this instance.
+    #
+    # Usage:
+    #   orm.id = 1; orm.load          — uses PK already set
+    #   orm.load("id = ?", [1])       — filter with params
+    #   orm.load("id = 1")            — filter string
+    #
+    # Returns true if a record was found, false otherwise.
+    def load(filter = nil, params = [], include: nil)
       @relationship_cache = {}
+      table = self.class.table_name
+
+      if filter.nil?
+        pk = self.class.primary_key
+        pk_col = self.class.field_mapping[pk.to_s] || pk
+        pk_value = __send__(pk)
+        return false if pk_value.nil?
+        sql = "SELECT * FROM #{table} WHERE #{pk_col} = ?"
+        params = [pk_value]
+      else
+        sql = "SELECT * FROM #{table} WHERE #{filter}"
+      end
+
       result = self.class.select_one(sql, params, include: include)
       return false unless result
 
@@ -634,7 +683,7 @@ module Tina4
       fk_value = __send__(fk.to_sym) if respond_to?(fk.to_sym)
       return nil unless fk_value
 
-      @relationship_cache[name] = klass.find(fk_value)
+      @relationship_cache[name] = klass.find_by_id(fk_value)
     end
 
     public
@@ -671,7 +720,7 @@ module Tina4
       fk_value = respond_to?(fk.to_sym) ? __send__(fk.to_sym) : nil
       return nil unless fk_value
 
-      related_class.find(fk_value)
+      related_class.find_by_id(fk_value)
     end
 
     # Instance-level aliases matching Python/PHP/Node.js naming

data/lib/tina4/queue.rb

@@ -1,75 +1,9 @@
 # frozen_string_literal: true
 require "json"
 require "securerandom"
+require_relative "job"
 
 module Tina4
-  class QueueMessage
-    attr_reader :id, :topic, :payload, :created_at, :attempts, :priority, :available_at
-    attr_accessor :status
-
-    def initialize(topic:, payload:, id: nil, priority: 0, available_at: nil, attempts: 0)
-      @id = id || SecureRandom.uuid
-      @topic = topic
-      @payload = payload
-      @created_at = Time.now
-      @attempts = attempts
-      @priority = priority
-      @available_at = available_at
-      @status = :pending
-    end
-
-    # Re-queue this message with incremented attempts.
-    # Delegates to the queue's backend via the queue reference.
-    def retry(queue:, delay_seconds: 0)
-      @attempts += 1
-      @status = :pending
-      @available_at = delay_seconds > 0 ? Time.now + delay_seconds : nil
-      queue.backend.enqueue(self)
-      self
-    end
-
-    def to_hash
-      h = {
-        id: @id,
-        topic: @topic,
-        payload: @payload,
-        created_at: @created_at.iso8601,
-        attempts: @attempts,
-        status: @status,
-        priority: @priority
-      }
-      h[:available_at] = @available_at.iso8601 if @available_at
-      h
-    end
-
-    def to_json(*_args)
-      JSON.generate(to_hash)
-    end
-
-    def increment_attempts!
-      @attempts += 1
-    end
-
-    # Mark this job as completed.
-    def complete
-      @status = :completed
-    end
-
-    # Mark this job as failed with a reason.
-    def fail(reason = "")
-      @status = :failed
-      @error = reason
-      @attempts += 1
-    end
-
-    # Reject this job with a reason. Alias for fail().
-    def reject(reason = "")
-      fail(reason)
-    end
-
-    attr_reader :error
-  end
-
   # Queue — unified wrapper for queue management operations.
   # Auto-detects backend from TINA4_QUEUE_BACKEND env var.
   #
@@ -91,21 +25,39 @@ module Tina4
       @backend = resolve_backend_arg(backend)
     end
 
-    # Push a job onto the queue. Returns the QueueMessage.
+    # Push a job onto the queue. Returns the Job.
     # priority: higher-priority messages are dequeued first (default 0).
     # delay_seconds: delay before the message becomes available (default 0).
     def push(payload, priority: 0, delay_seconds: 0)
       available_at = delay_seconds > 0 ? Time.now + delay_seconds : nil
-      message = QueueMessage.new(topic: @topic, payload: payload, priority: priority, available_at: available_at)
+      message = Job.new(topic: @topic, payload: payload, priority: priority, available_at: available_at)
       @backend.enqueue(message)
       message
     end
 
-    # Pop the next available job. Returns QueueMessage or nil.
+    # Pop the next available job. Returns Job or nil.
     def pop
       @backend.dequeue(@topic)
     end
 
+    # Clear all pending jobs from this queue's topic. Returns count removed.
+    def clear
+      return 0 unless @backend.respond_to?(:clear)
+      @backend.clear(@topic)
+    end
+
+    # Get jobs that failed but are still eligible for retry (under max_retries).
+    def failed
+      return [] unless @backend.respond_to?(:failed)
+      @backend.failed(@topic, max_retries: @max_retries)
+    end
+
+    # Retry a specific failed job by ID. Returns true if found and re-queued.
+    def retry(job_id, delay_seconds: 0)
+      return false unless @backend.respond_to?(:retry_job)
+      @backend.retry_job(@topic, job_id, delay_seconds: delay_seconds)
+    end
+
     # Get dead letter jobs — messages that exceeded max retries.
     def dead_letters
       return [] unless @backend.respond_to?(:dead_letters)
@@ -126,8 +78,8 @@ module Tina4
     end
 
     # Produce a message onto a topic. Convenience wrapper around push().
-    def produce(topic, payload)
-      message = QueueMessage.new(topic: topic, payload: payload)
+    def produce(topic, payload, priority: 0)
+      message = Job.new(topic: topic, payload: payload, priority: priority)
       @backend.enqueue(message)
       message
     end
@@ -156,7 +108,7 @@ module Tina4
     #   queue.consume("emails", poll_interval: 5) { |job| process(job) }
     #   queue.consume("emails", id: "abc-123") { |job| process(job) }
     #
-    def consume(topic = nil, id: nil, poll_interval: 1.0, &block)
+    def consume(topic = nil, id: nil, poll_interval: 1.0, iterations: 0, &block)
       topic ||= @topic
 
       if id
@@ -170,7 +122,9 @@ module Tina4
 
       # poll_interval=0 → single-pass drain (returns when empty)
       # poll_interval>0 → long-running poll (sleeps when empty, never returns)
+      # iterations>0    → stop after consuming N jobs
       if block_given?
+        consumed = 0
         loop do
           job = @backend.dequeue(topic)
           if job.nil?
@@ -179,9 +133,12 @@ module Tina4
             next
           end
           yield job
+          consumed += 1
+          break if iterations > 0 && consumed >= iterations
         end
       else
         Enumerator.new do |yielder|
+          consumed = 0
           loop do
             job = @backend.dequeue(topic)
             if job.nil?
@@ -190,15 +147,17 @@ module Tina4
               next
             end
             yielder << job
+            consumed += 1
+            break if iterations > 0 && consumed >= iterations
           end
         end
       end
     end
 
     # Pop a specific job by ID from the queue.
-    def pop_by_id(topic, id)
+    def pop_by_id(id)
       return nil unless @backend.respond_to?(:find_by_id)
-      @backend.find_by_id(topic, id)
+      @backend.find_by_id(@topic, id)
     end
 
     # Get the number of messages by status.

data/lib/tina4/queue_backends/kafka_backend.rb

@@ -45,7 +45,7 @@ module Tina4
         data = JSON.parse(msg.payload)
         @last_message = msg
 
-        Tina4::QueueMessage.new(
+        Tina4::Job.new(
           topic: data["topic"],
           payload: data["payload"],
           id: data["id"]
@@ -63,7 +63,7 @@ module Tina4
       end
 
       def dead_letter(message)
-        dead_msg = Tina4::QueueMessage.new(
+        dead_msg = Tina4::Job.new(
           topic: "#{message.topic}.dead_letter",
           payload: message.payload,
           id: message.id

data/lib/tina4/queue_backends/lite_backend.rb

@@ -52,7 +52,7 @@ module Tina4
           File.delete(chosen[:file])
           data = chosen[:data]
 
-          Tina4::QueueMessage.new(
+          Tina4::Job.new(
             topic: data["topic"] || topic.to_s,
             payload: data["payload"],
             id: data["id"],
@@ -176,7 +176,7 @@ module Tina4
           next if (data["attempts"] || 0) >= max_retries
 
           data["status"] = "pending"
-          msg = Tina4::QueueMessage.new(
+          msg = Tina4::Job.new(
             topic: data["topic"],
             payload: data["payload"],
             id: data["id"]
@@ -191,6 +191,57 @@ module Tina4
         count
       end
 
+      # Remove all pending jobs from a topic. Returns count removed.
+      def clear(topic)
+        dir = topic_path(topic)
+        return 0 unless Dir.exist?(dir)
+        count = 0
+        Dir.glob(File.join(dir, "*.json")).each do |file|
+          File.delete(file)
+          count += 1
+        end
+        count
+      end
+
+      # Get jobs that failed but are still eligible for retry (under max_retries).
+      def failed(topic, max_retries: 3)
+        return [] unless Dir.exist?(@dead_letter_dir)
+        jobs = []
+        Dir.glob(File.join(@dead_letter_dir, "*.json")).sort_by { |f| File.mtime(f) }.each do |file|
+          data = JSON.parse(File.read(file))
+          next unless data["topic"] == topic.to_s
+          next if (data["attempts"] || 0) >= max_retries
+          jobs << data
+        rescue JSON::ParserError
+          next
+        end
+        jobs
+      end
+
+      # Retry a specific failed job by ID. Returns true if found and re-queued.
+      def retry_job(topic, job_id, delay_seconds: 0)
+        return false unless Dir.exist?(@dead_letter_dir)
+        file = File.join(@dead_letter_dir, "#{job_id}.json")
+        return false unless File.exist?(file)
+
+        data = JSON.parse(File.read(file))
+        return false unless data["topic"] == topic.to_s
+
+        available_at = delay_seconds > 0 ? Time.now + delay_seconds : nil
+        msg = Tina4::Job.new(
+          topic: data["topic"],
+          payload: data["payload"],
+          id: data["id"],
+          attempts: (data["attempts"] || 0) + 1,
+          available_at: available_at
+        )
+        enqueue(msg)
+        File.delete(file)
+        true
+      rescue JSON::ParserError
+        false
+      end
+
       private
 
       def topic_path(topic)

data/lib/tina4/queue_backends/mongo_backend.rb

@@ -49,7 +49,7 @@ module Tina4
         )
         return nil unless doc
 
-        Tina4::QueueMessage.new(
+        Tina4::Job.new(
           topic: doc["topic"],
           payload: doc["payload"],
           id: doc["_id"]
@@ -82,7 +82,7 @@ module Tina4
 
       def dead_letters(topic, max_retries: 3)
         collection.find(topic: "#{topic}.dead_letter", status: "dead").map do |doc|
-          Tina4::QueueMessage.new(
+          Tina4::Job.new(
             topic: doc["topic"],
             payload: doc["payload"],
             id: doc["_id"]

data/lib/tina4/queue_backends/rabbitmq_backend.rb

@@ -31,7 +31,7 @@ module Tina4
         return nil unless payload
 
         data = JSON.parse(payload)
-        msg = Tina4::QueueMessage.new(
+        msg = Tina4::Job.new(
           topic: data["topic"],
           payload: data["payload"],
           id: data["id"]

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.10.75"
+  VERSION = "3.10.83"
 end

data/lib/tina4/websocket.rb

@@ -2,6 +2,7 @@
 require "socket"
 require "digest"
 require "base64"
+require "set"
 
 module Tina4
   class WebSocket
@@ -17,6 +18,7 @@ module Tina4
         close: [],
         error: []
       }
+      @rooms = {}  # room_name => Set of conn_ids
     end
 
     def on(event, &block)
@@ -69,6 +71,7 @@ module Tina4
           emit(:error, connection, e)
         ensure
           @connections.delete(conn_id)
+          remove_from_all_rooms(conn_id)
           emit(:close, connection)
           socket.close rescue nil
         end
@@ -83,15 +86,46 @@ module Tina4
       end
     end
 
+    # ── Rooms ──────────────────────────────────────────────────
+
+    def join_room_for(conn_id, room_name)
+      @rooms[room_name] ||= Set.new
+      @rooms[room_name].add(conn_id)
+    end
+
+    def leave_room_for(conn_id, room_name)
+      @rooms[room_name]&.delete(conn_id)
+    end
+
+    def room_count(room_name)
+      (@rooms[room_name] || Set.new).size
+    end
+
+    def get_room_connections(room_name)
+      ids = @rooms[room_name] || Set.new
+      ids.filter_map { |id| @connections[id] }
+    end
+
+    def broadcast_to_room(room_name, message, exclude: nil)
+      (get_room_connections(room_name)).each do |conn|
+        next if exclude && conn.id == exclude
+        conn.send_text(message)
+      end
+    end
+
     private
 
     def emit(event, *args)
       @handlers[event]&.each { |h| h.call(*args) }
     end
+
+    def remove_from_all_rooms(conn_id)
+      @rooms.each_value { |members| members.delete(conn_id) }
+    end
   end
 
   class WebSocketConnection
-    attr_reader :id
+    attr_reader :id, :rooms
     attr_accessor :params, :path
 
     def initialize(id, socket, ws_server: nil, path: "/")
@@ -100,6 +134,24 @@ module Tina4
       @params = {}
       @ws_server = ws_server
       @path = path
+      @rooms = Set.new
+    end
+
+    def join_room(room_name)
+      @rooms.add(room_name)
+      @ws_server&.join_room_for(@id, room_name)
+    end
+
+    def leave_room(room_name)
+      @rooms.delete(room_name)
+      @ws_server&.leave_room_for(@id, room_name)
+    end
+
+    def broadcast_to_room(room_name, message, exclude_self: false)
+      return unless @ws_server
+
+      exclude = exclude_self ? @id : nil
+      @ws_server.broadcast_to_room(room_name, message, exclude: exclude)
     end
 
     # Broadcast a message to all other connections on the same path

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.10.75
+  version: 3.10.83
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-07 00:00:00.000000000 Z
+date: 2026-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -324,6 +324,7 @@ files:
 - lib/tina4/graphql.rb
 - lib/tina4/health.rb
 - lib/tina4/html_element.rb
+- lib/tina4/job.rb
 - lib/tina4/localization.rb
 - lib/tina4/log.rb
 - lib/tina4/mcp.rb