tina4ruby 3.10.90 → 3.10.91

data/lib/tina4/queue_backends/lite_backend.rb

@@ -63,6 +63,45 @@ module Tina4
         end
       end
 
+      def dequeue_batch(topic, count)
+        @mutex.synchronize do
+          dir = topic_path(topic)
+          return [] unless Dir.exist?(dir)
+
+          now = Time.now
+          candidates = []
+
+          Dir.glob(File.join(dir, "*.json")).each do |f|
+            data = JSON.parse(File.read(f))
+            if data["available_at"]
+              available_at = Time.parse(data["available_at"])
+              next if available_at > now
+            end
+            candidates << { file: f, data: data, priority: data["priority"] || 0, mtime: File.mtime(f) }
+          rescue JSON::ParserError
+            next
+          end
+
+          return [] if candidates.empty?
+
+          candidates.sort_by! { |c| [-c[:priority], c[:mtime]] }
+          chosen = candidates.first(count)
+
+          chosen.map do |c|
+            File.delete(c[:file])
+            data = c[:data]
+            Tina4::Job.new(
+              topic: data["topic"] || topic.to_s,
+              payload: data["payload"],
+              id: data["id"],
+              priority: data["priority"] || 0,
+              available_at: data["available_at"] ? Time.parse(data["available_at"]) : nil,
+              attempts: data["attempts"] || 0
+            )
+          end
+        end
+      end
+
       def acknowledge(message)
         # File already deleted on dequeue
       end
@@ -219,7 +258,7 @@ module Tina4
       end
 
       # Retry all dead letter jobs for this topic. Returns true if any were re-queued.
-      def retry_job(topic, delay_seconds: 0)
+      def retry_job(topic, job_id: nil, delay_seconds: 0)
         return false unless Dir.exist?(@dead_letter_dir)
 
         available_at = delay_seconds > 0 ? Time.now + delay_seconds : nil
@@ -228,6 +267,7 @@ module Tina4
         Dir.glob(File.join(@dead_letter_dir, "*.json")).each do |file|
           data = JSON.parse(File.read(file))
           next unless data["topic"] == topic.to_s
+          next if job_id && data["id"] != job_id.to_s
 
           msg = Tina4::Job.new(
             topic: data["topic"],
@@ -239,6 +279,7 @@ module Tina4
           enqueue(msg)
           File.delete(file)
           count += 1
+          break if job_id  # found the specific job, stop scanning
         rescue JSON::ParserError
           next
         end

data/lib/tina4/rack_app.rb

@@ -80,7 +80,7 @@ module Tina4
       end
 
       # Route matching
-      result = Tina4::Router.find_route(path, method)
+      result = Tina4::Router.match(method, path)
       if result
         route, path_params = result
         rack_response = handle_route(env, route, path_params)
@@ -191,7 +191,7 @@ module Tina4
       response = Tina4::Response.new
 
       # Run global middleware (block-based + class-based before_* methods)
-      unless Tina4::Middleware.run_before(request, response)
+      unless Tina4::Middleware.run_before(Tina4::Middleware.global_middleware, request, response)
         # Middleware halted the request -- return whatever response was set
         return response.to_rack
       end
@@ -229,7 +229,7 @@ module Tina4
       final_response = result.equal?(response) ? result : Tina4::Response.auto_detect(result, response)
 
       # Run global after middleware (block-based + class-based after_* methods)
-      Tina4::Middleware.run_after(request, final_response)
+      Tina4::Middleware.run_after(Tina4::Middleware.global_middleware, request, final_response)
 
       final_response.to_rack
     end

data/lib/tina4/router.rb

@@ -3,7 +3,7 @@
 module Tina4
   class Route
     attr_reader :method, :path, :handler, :auth_handler, :swagger_meta,
-                :path_regex, :param_names, :middleware, :template
+                :path_regex, :param_names, :template
     attr_accessor :auth_required, :cached
 
     def initialize(method, path, handler, auth_handler: nil, swagger_meta: {}, middleware: [], template: nil)
@@ -44,6 +44,19 @@ module Tina4
       self
     end
 
+    # Dual-mode: getter (no args) returns the middleware array;
+    # setter (with args) appends middleware and returns self for chaining.
+    # Router.post("/api") { ... }.middleware(AuthMiddleware)
+    def middleware(*middleware_classes)
+      return @middleware if middleware_classes.empty?
+
+      @middleware = @middleware.dup + middleware_classes
+      # Custom middleware means developer handles auth — disable built-in gate
+      # unless .secure was explicitly called.
+      @auth_required = false unless @auth_required
+      self
+    end
+
     # Returns params hash if matched, false otherwise
     def match?(request_path, request_method = nil)
       return false if request_method && @method != "ANY" && @method != request_method.to_s.upcase
@@ -209,6 +222,11 @@ module Tina4
         @ws_routes ||= []
       end
 
+      # Parity alias — returns all registered WebSocket routes.
+      def get_web_socket_routes
+        ws_routes
+      end
+
       # Register a WebSocket route.
       # The handler block receives (connection, event, data) where:
       #   connection — WebSocketConnection with #send, #broadcast, #close, #params
@@ -240,7 +258,7 @@ module Tina4
         @method_index ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      def add_route(method, path, handler, auth_handler: nil, swagger_meta: {}, middleware: [], template: nil)
+      def add(method, path, handler, auth_handler: nil, swagger_meta: {}, middleware: [], template: nil)
         route = Route.new(method, path, handler,
                           auth_handler: auth_handler,
                           swagger_meta: swagger_meta,
@@ -251,33 +269,32 @@ module Tina4
         Tina4::Log.debug("Route registered: #{method.upcase} #{path}")
         route
       end
-
-      # Convenience registration methods matching tina4-python pattern
+      # Convenience registration methods
       def get(path, middleware: [], swagger_meta: {}, template: nil, &block)
-        add_route("GET", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+        add("GET", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
       end
 
       def post(path, middleware: [], swagger_meta: {}, template: nil, &block)
-        add_route("POST", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+        add("POST", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
       end
 
       def put(path, middleware: [], swagger_meta: {}, template: nil, &block)
-        add_route("PUT", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+        add("PUT", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
       end
 
       def patch(path, middleware: [], swagger_meta: {}, template: nil, &block)
-        add_route("PATCH", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+        add("PATCH", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
       end
 
       def delete(path, middleware: [], swagger_meta: {}, template: nil, &block)
-        add_route("DELETE", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+        add("DELETE", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
       end
 
       def any(path, middleware: [], swagger_meta: {}, template: nil, &block)
-        add_route("ANY", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+        add("ANY", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
       end
 
-      def find_route(path, method)
+      def find_route(method, path)
         normalized_method = method.upcase
         # Normalize path once (not per-route)
         normalized_path = path.gsub("\\", "/")
@@ -293,9 +310,10 @@ module Tina4
         nil
       end
 
-      # Alias for find_route().
-      def match(path, method)
-        find_route(path, method)
+      # Find a route matching method + path. Returns [route, params] or nil.
+      # match(method, path) — consistent with Python, PHP, and Node.
+      def match(method, path)
+        find_route(method, path)
       end
 
       # Register a class-based middleware globally.
@@ -319,6 +337,7 @@ module Tina4
         @method_index = Hash.new { |h, k| h[k] = [] }
         @ws_routes = []
       end
+      alias clear clear!
 
       def group(prefix, auth_handler: nil, middleware: [], &block)
         GroupContext.new(prefix, auth_handler, middleware).instance_eval(&block)
@@ -349,7 +368,7 @@ module Tina4
         define_method(m) do |path, middleware: [], swagger_meta: {}, template: nil, &handler|
           full_path = "#{@prefix}#{path}"
           combined_middleware = @middleware + middleware
-          Tina4::Router.add_route(m, full_path, handler,
+          Tina4::Router.add(m, full_path, handler,
                                   auth_handler: @auth_handler,
                                   swagger_meta: swagger_meta,
                                   middleware: combined_middleware,

data/lib/tina4/seeder.rb

@@ -85,6 +85,14 @@ module Tina4
     STREET_TYPES = %w[Street Avenue Road Drive Lane Boulevard Way Place].freeze
     COMPANY_WORDS = %w[Tech Global Apex Nova Core Prime Next Blue Bright Smart Swift Peak Fusion Pulse Vertex].freeze
     COMPANY_SUFFIXES = %w[Inc Corp Ltd LLC Group Solutions Systems Labs].freeze
+    JOB_TITLES = [
+      "Software Engineer", "Product Manager", "Designer", "Data Analyst",
+      "DevOps Engineer", "CEO", "CTO", "Sales Manager", "Marketing Lead",
+      "Accountant", "Operations Manager", "QA Engineer", "UX Researcher",
+      "Support Specialist", "HR Manager", "Technical Writer"
+    ].freeze
+    CURRENCIES = %w[USD EUR GBP JPY CAD AUD CHF ZAR INR CNY].freeze
+    CREDIT_CARD_PREFIXES = %w[4111 4242 5500 5105].freeze
 
     def initialize(seed: nil)
       @rng = seed ? Random.new(seed) : Random.new
@@ -221,6 +229,25 @@ module Tina4
       "#{w1}#{w2} #{suffix}"
     end
 
+    def job_title
+      JOB_TITLES[@rng.rand(JOB_TITLES.length)]
+    end
+
+    def currency
+      CURRENCIES[@rng.rand(CURRENCIES.length)]
+    end
+
+    def ip_address
+      "#{@rng.rand(1..255)}.#{@rng.rand(0..255)}.#{@rng.rand(0..255)}.#{@rng.rand(1..254)}"
+    end
+
+    # Generate a fake credit card number (test numbers only, e.g. 4111...).
+    def credit_card
+      prefix = CREDIT_CARD_PREFIXES[@rng.rand(CREDIT_CARD_PREFIXES.length)]
+      rest = Array.new(12) { @rng.rand(0..9) }.join
+      prefix + rest
+    end
+
     def color_hex
       "#%06x" % @rng.rand(0..0xFFFFFF)
     end
@@ -235,6 +262,11 @@ module Tina4
       Array.new(length) { chars[@rng.rand(chars.length)] }.join
     end
 
+    # Run a generator block `count` times and return the results.
+    def run(count = 1, &block)
+      Array.new(count) { block.call }
+    end
+
     # Generate appropriate data based on field definition and column name.
     def for_field(field_def, column_name = nil)
       col = (column_name || "").to_s.downcase
@@ -495,7 +527,7 @@ module Tina4
   # Run all seed files in the given folder.
   #
   # @param seed_folder [String] path to seed files (default: "seeds")
-  def self.seed(seed_folder: "seeds", clear: false)
+  def self.seed_dir(seed_folder: "seeds", clear: false)
     unless Dir.exist?(seed_folder)
       Tina4::Log.info("Seeder: No seeds folder found at #{seed_folder}")
       return

data/lib/tina4/session.rb

@@ -108,10 +108,44 @@ module Tina4
       @id
     end
 
+    # Start or resume a session. If session_id is given, load that session;
+    # otherwise generate a new ID. Returns the session ID string.
+    def start(session_id = nil)
+      if session_id
+        @id = session_id
+        @data = load_session
+      else
+        @id = SecureRandom.hex(32)
+        @data = {}
+      end
+      @modified = false
+      @id
+    end
+
+    # Returns the current session ID string.
+    def get_session_id
+      @id
+    end
+
+    # Reads raw session data for a given session ID from backend storage.
+    # Returns the data hash or nil.
+    def read(session_id)
+      @handler.read(session_id)
+    end
+
+    # Writes raw session data for a given session ID to backend storage.
+    def write(session_id, data, ttl = nil)
+      if ttl
+        @handler.write(session_id, data, ttl)
+      else
+        @handler.write(session_id, data)
+      end
+    end
+
     # Garbage collection: remove expired sessions from the handler
-    def gc(max_age = nil)
-      max_age ||= @options[:max_age]
-      @handler.gc(max_age) if @handler.respond_to?(:gc)
+    def gc(max_lifetime = nil)
+      max_lifetime ||= @options[:max_age]
+      @handler.gc(max_lifetime) if @handler.respond_to?(:gc)
     end
 
     def cookie_header(cookie_name = nil)
@@ -219,9 +253,29 @@ module Tina4
       @session.regenerate
     end
 
-    def gc(max_age = nil)
+    def gc(max_lifetime = nil)
+      ensure_loaded
+      @session.gc(max_lifetime)
+    end
+
+    def start(session_id = nil)
+      ensure_loaded
+      @session.start(session_id)
+    end
+
+    def get_session_id
+      ensure_loaded
+      @session.get_session_id
+    end
+
+    def read(session_id)
+      ensure_loaded
+      @session.read(session_id)
+    end
+
+    def write(session_id, data, ttl = nil)
       ensure_loaded
-      @session.gc(max_age)
+      @session.write(session_id, data, ttl)
     end
 
     def cookie_header(cookie_name = nil)

data/lib/tina4/sql_translation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "digest"
+require_relative "cache"
 
 module Tina4
   # Cross-engine SQL translator.
@@ -154,142 +155,4 @@ module Tina4
       end
     end
   end
-
-  # In-memory cache with TTL support for query results.
-  #
-  # Usage:
-  #   cache = Tina4::QueryCache.new(default_ttl: 60, max_size: 1000)
-  #   cache.set("key", "value", ttl: 30)
-  #   cache.get("key")  # => "value"
-  #
-  class QueryCache
-    CacheEntry = Struct.new(:value, :expires_at, :tags)
-
-    # @param default_ttl [Integer] default TTL in seconds (default: 300)
-    # @param max_size [Integer] maximum number of cache entries (default: 1000)
-    def initialize(default_ttl: 300, max_size: 1000)
-      @default_ttl = default_ttl
-      @max_size = max_size
-      @store = {}
-      @mutex = Mutex.new
-    end
-
-    # Store a value with optional TTL and tags.
-    #
-    # @param key [String]
-    # @param value [Object]
-    # @param ttl [Integer, nil] TTL in seconds (nil uses default)
-    # @param tags [Array<String>] optional tags for grouped invalidation
-    def set(key, value, ttl: nil, tags: [])
-      ttl ||= @default_ttl
-      expires_at = Time.now.to_f + ttl
-
-      @mutex.synchronize do
-        # Evict oldest if at capacity
-        if @store.size >= @max_size && !@store.key?(key)
-          oldest_key = @store.keys.first
-          @store.delete(oldest_key)
-        end
-        @store[key] = CacheEntry.new(value, expires_at, tags)
-      end
-    end
-
-    # Retrieve a cached value. Returns nil if expired or missing.
-    #
-    # @param key [String]
-    # @param default [Object] value to return if key is missing
-    # @return [Object, nil]
-    def get(key, default = nil)
-      @mutex.synchronize do
-        entry = @store[key]
-        return default unless entry
-
-        if Time.now.to_f > entry.expires_at
-          @store.delete(key)
-          return default
-        end
-
-        entry.value
-      end
-    end
-
-    # Check if a key exists and is not expired.
-    #
-    # @param key [String]
-    # @return [Boolean]
-    def has?(key)
-      @mutex.synchronize do
-        entry = @store[key]
-        return false unless entry
-
-        if Time.now.to_f > entry.expires_at
-          @store.delete(key)
-          return false
-        end
-
-        true
-      end
-    end
-
-    # Delete a key from the cache.
-    #
-    # @param key [String]
-    # @return [Boolean] true if the key was present
-    def delete(key)
-      @mutex.synchronize do
-        !@store.delete(key).nil?
-      end
-    end
-
-    # Clear all entries from the cache.
-    def clear
-      @mutex.synchronize { @store.clear }
-    end
-
-    # Clear all entries with a given tag.
-    #
-    # @param tag [String]
-    # @return [Integer] number of entries removed
-    def clear_tag(tag)
-      @mutex.synchronize do
-        keys_to_remove = @store.select { |_k, v| v.tags.include?(tag) }.keys
-        keys_to_remove.each { |k| @store.delete(k) }
-        keys_to_remove.size
-      end
-    end
-
-    # Remove all expired entries.
-    #
-    # @return [Integer] number of entries removed
-    def sweep
-      @mutex.synchronize do
-        now = Time.now.to_f
-        keys_to_remove = @store.select { |_k, v| now > v.expires_at }.keys
-        keys_to_remove.each { |k| @store.delete(k) }
-        keys_to_remove.size
-      end
-    end
-
-    # Fetch from cache, or compute and store.
-    #
-    # @param key [String]
-    # @param ttl [Integer] TTL in seconds
-    # @param block [Proc] factory to compute the value if not cached
-    # @return [Object]
-    def remember(key, ttl, &block)
-      cached = get(key)
-      return cached unless cached.nil?
-
-      value = block.call
-      set(key, value, ttl: ttl)
-      value
-    end
-
-    # Current number of entries in the cache.
-    #
-    # @return [Integer]
-    def size
-      @mutex.synchronize { @store.size }
-    end
-  end
 end

data/lib/tina4/test_client.rb

@@ -114,7 +114,7 @@ module Tina4
       end
 
       # Match route
-      result = Tina4::Router.find_route(clean_path, method.upcase)
+      result = Tina4::Router.match(method.upcase, clean_path)
 
       unless result
         return TestResponse.new([404, { "content-type" => "application/json" }, ['{"error":"Not found"}']])

data/lib/tina4/version.rb

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

data/lib/tina4/websocket.rb

@@ -30,6 +30,71 @@ module Tina4
       upgrade.downcase == "websocket"
     end
 
+    def get_clients
+      @connections
+    end
+
+    def start(host: "0.0.0.0", port: 7147)
+      require "socket"
+      @server_socket = TCPServer.new(host, port)
+      @running = true
+      @server_thread = Thread.new do
+        while @running
+          begin
+            client = @server_socket.accept
+            env = {}
+            handle_upgrade(env, client)
+          rescue => e
+            break unless @running
+          end
+        end
+      end
+      self
+    end
+
+    def stop
+      @running = false
+      @server_socket&.close rescue nil
+      @server_thread&.join(1)
+      @connections.each_value { |conn| conn.close rescue nil }
+      @connections.clear
+    end
+
+    def broadcast(message, exclude: nil, path: nil)
+      @connections.each do |id, conn|
+        next if exclude && id == exclude
+        next if path && conn.path != path
+        conn.send_text(message)
+      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
+
     def handle_upgrade(env, socket)
       key = env["HTTP_SEC_WEBSOCKET_KEY"]
       return unless key
@@ -78,43 +143,6 @@ module Tina4
       end
     end
 
-    def broadcast(message, exclude: nil, path: nil)
-      @connections.each do |id, conn|
-        next if exclude && id == exclude
-        next if path && conn.path != path
-        conn.send_text(message)
-      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
@@ -218,8 +246,6 @@ module Tina4
       nil
     end
 
-    private
-
     def build_frame(opcode, data)
       frame = [0x80 | opcode].pack("C")
       length = data.bytesize