tina4ruby 0.4.0

data/lib/tina4/queue.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+require "json"
+require "securerandom"
+
+module Tina4
+  class QueueMessage
+    attr_reader :id, :topic, :payload, :created_at, :attempts
+    attr_accessor :status
+
+    def initialize(topic:, payload:, id: nil)
+      @id = id || SecureRandom.uuid
+      @topic = topic
+      @payload = payload
+      @created_at = Time.now
+      @attempts = 0
+      @status = :pending
+    end
+
+    def to_hash
+      {
+        id: @id,
+        topic: @topic,
+        payload: @payload,
+        created_at: @created_at.iso8601,
+        attempts: @attempts,
+        status: @status
+      }
+    end
+
+    def to_json(*_args)
+      JSON.generate(to_hash)
+    end
+
+    def increment_attempts!
+      @attempts += 1
+    end
+  end
+
+  class Producer
+    def initialize(backend: nil)
+      @backend = backend || Tina4::QueueBackends::LiteBackend.new
+    end
+
+    def publish(topic, payload)
+      message = QueueMessage.new(topic: topic, payload: payload)
+      @backend.enqueue(message)
+      Tina4::Debug.debug("Message published to #{topic}: #{message.id}")
+      message
+    end
+
+    def publish_batch(topic, payloads)
+      payloads.map { |p| publish(topic, p) }
+    end
+  end
+
+  class Consumer
+    def initialize(topic:, backend: nil, max_retries: 3)
+      @topic = topic
+      @backend = backend || Tina4::QueueBackends::LiteBackend.new
+      @max_retries = max_retries
+      @handlers = []
+      @running = false
+    end
+
+    def on_message(&block)
+      @handlers << block
+    end
+
+    def start(poll_interval: 1)
+      @running = true
+      Tina4::Debug.info("Consumer started for topic: #{@topic}")
+
+      while @running
+        message = @backend.dequeue(@topic)
+        if message
+          process_message(message)
+        else
+          sleep(poll_interval)
+        end
+      end
+    end
+
+    def stop
+      @running = false
+      Tina4::Debug.info("Consumer stopped for topic: #{@topic}")
+    end
+
+    def process_one
+      message = @backend.dequeue(@topic)
+      process_message(message) if message
+    end
+
+    private
+
+    def process_message(message)
+      message.increment_attempts!
+      message.status = :processing
+
+      @handlers.each do |handler|
+        handler.call(message)
+      end
+
+      message.status = :completed
+      @backend.acknowledge(message)
+    rescue => e
+      Tina4::Debug.error("Queue message failed: #{message.id} - #{e.message}")
+      message.status = :failed
+
+      if message.attempts < @max_retries
+        message.status = :pending
+        @backend.requeue(message)
+      else
+        @backend.dead_letter(message)
+      end
+    end
+  end
+end

data/lib/tina4/queue_backends/kafka_backend.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Tina4
+  module QueueBackends
+    class KafkaBackend
+      def initialize(options = {})
+        require "rdkafka"
+        @brokers = options[:brokers] || "localhost:9092"
+        @group_id = options[:group_id] || "tina4_consumer_group"
+
+        producer_config = {
+          "bootstrap.servers" => @brokers
+        }
+        @producer = Rdkafka::Config.new(producer_config).producer
+
+        consumer_config = {
+          "bootstrap.servers" => @brokers,
+          "group.id" => @group_id,
+          "auto.offset.reset" => "earliest",
+          "enable.auto.commit" => "false"
+        }
+        @consumer = Rdkafka::Config.new(consumer_config).consumer
+        @subscribed_topics = []
+      rescue LoadError
+        raise "Kafka backend requires the 'rdkafka' gem. Install with: gem install rdkafka"
+      end
+
+      def enqueue(message)
+        @producer.produce(
+          topic: message.topic,
+          payload: message.to_json,
+          key: message.id
+        ).wait
+      end
+
+      def dequeue(topic)
+        unless @subscribed_topics.include?(topic)
+          @consumer.subscribe(topic)
+          @subscribed_topics << topic
+        end
+
+        msg = @consumer.poll(1000)
+        return nil unless msg
+
+        data = JSON.parse(msg.payload)
+        @last_message = msg
+
+        Tina4::QueueMessage.new(
+          topic: data["topic"],
+          payload: data["payload"],
+          id: data["id"]
+        )
+      rescue Rdkafka::RdkafkaError
+        nil
+      end
+
+      def acknowledge(_message)
+        @consumer.commit if @last_message
+      end
+
+      def requeue(message)
+        enqueue(message)
+      end
+
+      def dead_letter(message)
+        dead_msg = Tina4::QueueMessage.new(
+          topic: "#{message.topic}.dead_letter",
+          payload: message.payload,
+          id: message.id
+        )
+        enqueue(dead_msg)
+      end
+
+      def close
+        @producer&.close
+        @consumer&.close
+      end
+    end
+  end
+end

data/lib/tina4/queue_backends/lite_backend.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require "json"
+require "fileutils"
+
+module Tina4
+  module QueueBackends
+    class LiteBackend
+      def initialize(options = {})
+        @dir = options[:dir] || File.join(Dir.pwd, ".queue")
+        @dead_letter_dir = File.join(@dir, "dead_letter")
+        FileUtils.mkdir_p(@dir)
+        FileUtils.mkdir_p(@dead_letter_dir)
+        @mutex = Mutex.new
+      end
+
+      def enqueue(message)
+        @mutex.synchronize do
+          topic_dir = topic_path(message.topic)
+          FileUtils.mkdir_p(topic_dir)
+          path = File.join(topic_dir, "#{message.id}.json")
+          File.write(path, message.to_json)
+        end
+      end
+
+      def dequeue(topic)
+        @mutex.synchronize do
+          dir = topic_path(topic)
+          return nil unless Dir.exist?(dir)
+
+          files = Dir.glob(File.join(dir, "*.json")).sort_by { |f| File.mtime(f) }
+          return nil if files.empty?
+
+          file = files.first
+          data = JSON.parse(File.read(file))
+          File.delete(file)
+
+          Tina4::QueueMessage.new(
+            topic: data["topic"],
+            payload: data["payload"],
+            id: data["id"]
+          )
+        end
+      end
+
+      def acknowledge(message)
+        # File already deleted on dequeue
+      end
+
+      def requeue(message)
+        enqueue(message)
+      end
+
+      def dead_letter(message)
+        path = File.join(@dead_letter_dir, "#{message.id}.json")
+        File.write(path, message.to_json)
+      end
+
+      def size(topic)
+        dir = topic_path(topic)
+        return 0 unless Dir.exist?(dir)
+        Dir.glob(File.join(dir, "*.json")).length
+      end
+
+      def topics
+        return [] unless Dir.exist?(@dir)
+        Dir.children(@dir)
+           .reject { |d| d == "dead_letter" }
+           .select { |d| File.directory?(File.join(@dir, d)) }
+      end
+
+      private
+
+      def topic_path(topic)
+        safe_topic = topic.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")
+        File.join(@dir, safe_topic)
+      end
+    end
+  end
+end

data/lib/tina4/queue_backends/rabbitmq_backend.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Tina4
+  module QueueBackends
+    class RabbitmqBackend
+      def initialize(options = {})
+        require "bunny"
+        @connection = Bunny.new(
+          host: options[:host] || "localhost",
+          port: options[:port] || 5672,
+          username: options[:username] || "guest",
+          password: options[:password] || "guest",
+          vhost: options[:vhost] || "/"
+        )
+        @connection.start
+        @channel = @connection.create_channel
+        @queues = {}
+        @exchanges = {}
+      rescue LoadError
+        raise "RabbitMQ backend requires the 'bunny' gem. Install with: gem install bunny"
+      end
+
+      def enqueue(message)
+        queue = get_queue(message.topic)
+        queue.publish(message.to_json, persistent: true)
+      end
+
+      def dequeue(topic)
+        queue = get_queue(topic)
+        delivery_info, _properties, payload = queue.pop
+        return nil unless payload
+
+        data = JSON.parse(payload)
+        msg = Tina4::QueueMessage.new(
+          topic: data["topic"],
+          payload: data["payload"],
+          id: data["id"]
+        )
+        @last_delivery_tag = delivery_info.delivery_tag
+        msg
+      end
+
+      def acknowledge(_message)
+        @channel.acknowledge(@last_delivery_tag) if @last_delivery_tag
+      end
+
+      def requeue(message)
+        enqueue(message)
+      end
+
+      def dead_letter(message)
+        dlq = get_queue("#{message.topic}.dead_letter")
+        dlq.publish(message.to_json, persistent: true)
+      end
+
+      def size(topic)
+        queue = get_queue(topic)
+        queue.message_count
+      end
+
+      def close
+        @channel&.close
+        @connection&.close
+      end
+
+      private
+
+      def get_queue(topic)
+        @queues[topic] ||= @channel.queue(topic, durable: true)
+      end
+    end
+  end
+end

data/lib/tina4/rack_app.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  class RackApp
+    STATIC_DIRS = %w[public src/public src/assets assets].freeze
+
+    # Pre-built frozen responses for zero-allocation fast paths
+    CORS_HEADERS = {
+      "access-control-allow-origin" => "*",
+      "access-control-allow-methods" => "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+      "access-control-allow-headers" => "Content-Type, Authorization, Accept",
+      "access-control-max-age" => "86400"
+    }.freeze
+
+    OPTIONS_RESPONSE = [204, CORS_HEADERS, [""]].freeze
+
+    def initialize(root_dir: Dir.pwd)
+      @root_dir = root_dir
+      # Pre-compute static roots at boot (not per-request)
+      @static_roots = STATIC_DIRS.map { |d| File.join(root_dir, d) }
+                                  .select { |d| Dir.exist?(d) }
+                                  .freeze
+    end
+
+    def call(env)
+      method = env["REQUEST_METHOD"]
+      path = env["PATH_INFO"] || "/"
+
+      # Fast-path: OPTIONS preflight (zero allocation)
+      return OPTIONS_RESPONSE if method == "OPTIONS"
+
+      # Fast-path: API routes skip static file + swagger checks entirely
+      unless path.start_with?("/api/")
+        # Swagger
+        if path == "/swagger" || path == "/swagger/"
+          return serve_swagger_ui
+        end
+        if path == "/swagger/openapi.json"
+          return serve_openapi_json
+        end
+
+        # Static files (only for non-API paths)
+        static_response = try_static(path)
+        return static_response if static_response
+      end
+
+      # Route matching
+      result = Tina4::Router.find_route(path, method)
+      if result
+        route, path_params = result
+        handle_route(env, route, path_params)
+      else
+        handle_404(path)
+      end
+    rescue => e
+      handle_500(e)
+    end
+
+    private
+
+    def handle_route(env, route, path_params)
+      # Auth check
+      if route.auth_handler
+        auth_result = route.auth_handler.call(env)
+        return handle_403 unless auth_result
+      end
+
+      request = Tina4::Request.new(env, path_params)
+      response = Tina4::Response.new
+
+      # Execute handler
+      result = route.handler.call(request, response)
+
+      # Skip auto_detect if handler already returned the response object
+      final_response = result.equal?(response) ? result : Tina4::Response.auto_detect(result, response)
+      final_response.to_rack
+    end
+
+    def try_static(path)
+      return nil if path.include?("..")
+
+      @static_roots.each do |root|
+        full_path = File.join(root, path)
+        if File.file?(full_path)
+          return serve_static_file(full_path)
+        end
+
+        # Only try index.html for directory-like paths
+        if path.end_with?("/") || !path.include?(".")
+          index_path = File.join(full_path, "index.html")
+          if File.file?(index_path)
+            return serve_static_file(index_path)
+          end
+        end
+      end
+      nil
+    end
+
+    def serve_static_file(full_path)
+      ext = File.extname(full_path).downcase
+      content_type = Tina4::Response::MIME_TYPES[ext] || "application/octet-stream"
+      [200, { "content-type" => content_type }, [File.binread(full_path)]]
+    end
+
+    def serve_swagger_ui
+      html = <<~HTML
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+          <meta charset="UTF-8">
+          <title>API Documentation</title>
+          <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css">
+        </head>
+        <body>
+          <div id="swagger-ui"></div>
+          <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+          <script>
+            SwaggerUIBundle({ url: '/swagger/openapi.json', dom_id: '#swagger-ui' });
+          </script>
+        </body>
+        </html>
+      HTML
+      [200, { "content-type" => "text/html; charset=utf-8" }, [html]]
+    end
+
+    def serve_openapi_json
+      spec = Tina4::Swagger.generate
+      [200, { "content-type" => "application/json; charset=utf-8" }, [JSON.generate(spec)]]
+    end
+
+    def handle_403
+      body = Tina4::Template.render_error(403) rescue "403 Forbidden"
+      [403, { "content-type" => "text/html" }, [body]]
+    end
+
+    def handle_404(path)
+      Tina4::Debug.warning("404 Not Found: #{path}")
+      body = Tina4::Template.render_error(404) rescue "404 Not Found"
+      [404, { "content-type" => "text/html" }, [body]]
+    end
+
+    def handle_500(error)
+      Tina4::Debug.error("500 Internal Server Error: #{error.message}")
+      Tina4::Debug.error(error.backtrace&.first(10)&.join("\n"))
+      body = Tina4::Template.render_error(500) rescue "500 Internal Server Error: #{error.message}"
+      [500, { "content-type" => "text/html" }, [body]]
+    end
+  end
+end

data/lib/tina4/request.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+require "uri"
+require "json"
+
+module Tina4
+  class Request
+    attr_reader :env, :method, :path, :query_string, :content_type,
+                :path_params, :ip
+
+    def initialize(env, path_params = {})
+      @env = env
+      @method = env["REQUEST_METHOD"]
+      @path = env["PATH_INFO"] || "/"
+      @query_string = env["QUERY_STRING"] || ""
+      @content_type = env["CONTENT_TYPE"] || ""
+      @ip = env["REMOTE_ADDR"] || "127.0.0.1"
+      @path_params = path_params
+
+      # Lazy-initialized fields (nil = not yet computed)
+      @headers = nil
+      @cookies = nil
+      @session = nil
+      @body = nil
+      @params = nil
+      @files = nil
+      @json_body = nil
+    end
+
+    # Lazy accessors — only compute when needed
+    def headers
+      @headers ||= extract_headers
+    end
+
+    def cookies
+      @cookies ||= parse_cookies
+    end
+
+    def session
+      @session ||= @env["tina4.session"] || {}
+    end
+
+    def body
+      @body ||= read_body
+    end
+
+    def files
+      @files ||= extract_files
+    end
+
+    def params
+      @params ||= build_params
+    end
+
+    def [](key)
+      params[key.to_s] || params[key.to_sym] || @path_params[key.to_sym]
+    end
+
+    def header(name)
+      headers[name.to_s.downcase.gsub("-", "_")]
+    end
+
+    def json_body
+      @json_body ||= begin
+        JSON.parse(body)
+      rescue JSON::ParserError, TypeError
+        {}
+      end
+    end
+
+    def bearer_token
+      auth = header("authorization") || ""
+      auth.sub(/\ABearer\s+/i, "") if auth =~ /\ABearer\s+/i
+    end
+
+    private
+
+    def extract_headers
+      h = {}
+      @env.each do |key, value|
+        if key.start_with?("HTTP_")
+          h[key[5..].downcase] = value
+        end
+      end
+      h
+    end
+
+    def parse_cookies
+      cookie_str = @env["HTTP_COOKIE"]
+      return {} unless cookie_str && !cookie_str.empty?
+
+      result = {}
+      cookie_str.split(";").each do |pair|
+        key, value = pair.strip.split("=", 2)
+        result[key] = value if key
+      end
+      result
+    end
+
+    def read_body
+      input = @env["rack.input"]
+      return "" unless input
+      input.rewind if input.respond_to?(:rewind)
+      data = input.read || ""
+      input.rewind if input.respond_to?(:rewind)
+      data
+    end
+
+    def build_params
+      p = {}
+
+      # Query string params
+      parse_query_string(@query_string, p) unless @query_string.empty?
+
+      # Body params
+      if @content_type.include?("application/json")
+        json_body.each { |k, v| p[k.to_s] = v }
+      elsif @content_type.include?("application/x-www-form-urlencoded")
+        parse_query_string(body, p)
+      end
+
+      # Path params (highest priority)
+      @path_params.each { |k, v| p[k.to_s] = v }
+      p
+    end
+
+    def parse_query_string(qs, target = {})
+      return target if qs.nil? || qs.empty?
+      qs.split("&").each do |pair|
+        key, value = pair.split("=", 2)
+        target[URI.decode_www_form_component(key.to_s)] = URI.decode_www_form_component(value.to_s)
+      end
+      target
+    end
+
+    def extract_files
+      result = {}
+      return result unless @content_type.include?("multipart/form-data")
+      begin
+        form_hash = @env["rack.request.form_hash"]
+        if form_hash
+          form_hash.each do |key, value|
+            if value.is_a?(Hash) && value[:tempfile]
+              result[key] = {
+                filename: value[:filename],
+                type: value[:type],
+                tempfile: value[:tempfile],
+                size: value[:tempfile].size
+              }
+            end
+          end
+        end
+      rescue StandardError
+        # Multipart parsing failed
+      end
+      result
+    end
+  end
+end