tina4ruby 3.2.1 → 3.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9e0a35ede3d5672d8d4b1c4197129db19443f60638e0596b1e94f367f9a40aa
-  data.tar.gz: 37d5d5d98b0511ac523eeec07d8b2ada21d5a47553bab176ccbce9a01a600389
+  metadata.gz: b43c80adf7c00f71f0c14d64b4660f612b0124008b6a4821f431bae1d25c88d8
+  data.tar.gz: ca4230e2b17265849c05e5118c095f7359a7728036e299dc2813a56c53f85c47
 SHA512:
-  metadata.gz: 9f9f9b1240111c24ba20e461439c55c043792206f5b2150811f2c8d97b1e0e7e937d644777d4c2a06c59888b994f01aa8d54ebcffdad5dffcbdca159f3868fab
-  data.tar.gz: 581ac0b6d4b0493f0d787d53846d9c1811e9dab6515797ad693ecceec8e5b7401e92d08319b434c3729df0321b3399b8b73019e2b701d39664fa2f69c8baa20a
+  metadata.gz: 8200644fd078c8c4cb635610bef5392daddda3f86d1d7366973d16ffbd9457eb9e710db6cba8430384ff6b052b55dbbff0129c3ca31f878e067aab608e053ed0
+  data.tar.gz: 900b1b9f2fa791c1ebfcd5f0e492d73ade490c7c48126d3b2b1ff71f5d6a41ae8991552d69ae2ae3b4bdbff884a6aebfd3f37d01b6fa2bb163d2779dea53a19d

data/README.md

@@ -9,6 +9,14 @@
   Laravel joy. Ruby speed. 10x less code. Zero third-party dependencies.
 </p>
 
+<p align="center">
+  <a href="https://rubygems.org/gems/tina4"><img src="https://img.shields.io/gem/v/tina4?color=7b1fa2&label=RubyGems" alt="Gem"></a>
+  <img src="https://img.shields.io/badge/tests-1%2C578%20passing-brightgreen" alt="Tests">
+  <img src="https://img.shields.io/badge/features-38-blue" alt="Features">
+  <img src="https://img.shields.io/badge/dependencies-0-brightgreen" alt="Zero Deps">
+  <a href="https://tina4.com"><img src="https://img.shields.io/badge/docs-tina4.com-7b1fa2" alt="Docs"></a>
+</p>
+
 <p align="center">
   <a href="https://tina4.com">Documentation</a> &bull;
   <a href="#getting-started">Getting Started</a> &bull;
@@ -17,14 +25,6 @@
   <a href="https://tina4.com">tina4.com</a>
 </p>
 
-<p align="center">
-  <img src="https://img.shields.io/badge/tests-1577%20passing-brightgreen" alt="Tests">
-  <img src="https://img.shields.io/badge/carbonah-A%2B%20rated-00cc44" alt="Carbonah A+">
-  <img src="https://img.shields.io/badge/zero--dep-core-blue" alt="Zero Dependencies">
-  <img src="https://img.shields.io/badge/ruby-3.1%2B-blue" alt="Ruby 3.1+">
-  <img src="https://img.shields.io/badge/license-MIT-lightgrey" alt="MIT License">
-</p>
-
 ---
 
 ## Quick Start
@@ -87,16 +87,16 @@ Every feature is built from scratch -- no gem install, no node_modules, no third
 | **Templates** | Frond engine (Twig-compatible), inheritance, partials, 35+ filters, macros, fragment caching, sandboxing |
 | **ORM** | Active Record, typed fields with validation, soft delete, relationships (`has_one`/`has_many`/`belongs_to`), scopes, result caching, multi-database |
 | **Database** | SQLite, PostgreSQL, MySQL, MSSQL, Firebird -- unified adapter interface, query caching (TINA4_DB_CACHE=true for 4x speedup) |
-| **Auth** | Zero-dep JWT (RS256), sessions (file, Redis, MongoDB), password hashing, form tokens |
-| **API** | Swagger/OpenAPI auto-generation, GraphQL with ORM auto-schema and GraphiQL IDE |
-| **Background** | DB-backed queue with priority, delayed jobs, retry, batch processing, multi-queue |
+| **Auth** | Zero-dep JWT (HS256/RS256), sessions (file/Redis/Valkey/MongoDB/database), password hashing, form tokens |
+| **API** | Swagger/OpenAPI auto-generation, GraphQL with ORM auto-schema and GraphiQL IDE, WSDL/SOAP with auto WSDL |
+| **Background** | Queue (SQLite/RabbitMQ/Kafka/MongoDB) with priority, delayed jobs, retry, batch processing |
 | **Real-time** | Native WebSocket (RFC 6455), per-path routing, connection manager |
 | **Frontend** | tina4-css (~24 KB), frond.js helper, SCSS compiler, live reload, CSS hot-reload |
 | **DX** | Dev admin dashboard, error overlay, request inspector, AI tool integration, Carbonah green benchmarks |
 | **Data** | Migrations with rollback, 50+ fake data generators, ORM and table seeders |
 | **Other** | REST client, localization (6 languages), cache (memory/Redis/file), event system, inline testing, messenger (.env driven), configurable error pages |
 
-**1,577 tests across 38 built-in features. Zero dependencies. All Carbonah benchmarks rated A+.**
+**1,578 tests across 38 built-in features. Zero dependencies. All Carbonah benchmarks rated A+.**
 
 For full documentation visit **[tina4.com](https://tina4.com)**.
 
@@ -358,7 +358,7 @@ db = Tina4::Database.new("mysql://localhost:3306/mydb", username: "user", passwo
 db = Tina4::Database.new("mssql://localhost:1433/mydb", username: "sa", password: "pass")
 db = Tina4::Database.new("firebird://localhost:3050/path/to/db", username: "SYSDBA", password: "masterkey")
 
-result = db.fetch("SELECT * FROM users WHERE age > ?", [18], limit: 20, skip: 0)
+result = db.fetch("SELECT * FROM users WHERE age > ?", [18], limit: 20, offset: 0)
 row = db.fetch_one("SELECT * FROM users WHERE id = ?", [1])
 db.insert("users", { name: "Alice", email: "alice@test.com" })
 db.commit
@@ -381,8 +381,8 @@ end
 ### JWT Authentication
 
 ```ruby
-token = Tina4::Auth.create_token({ user_id: 42 })
-result = Tina4::Auth.validate_token(token)
+token = Tina4::Auth.get_token({ user_id: 42 })
+result = Tina4::Auth.valid_token(token)
 payload = Tina4::Auth.get_payload(token)
 ```
 
@@ -400,11 +400,10 @@ Backends: file (default), Redis, MongoDB. Set via `TINA4_SESSION_HANDLER` in `.e
 ### Queues
 
 ```ruby
-producer = Tina4::Producer.new(Tina4::Queue.new(topic: "emails"))
-producer.produce({ to: "alice@example.com" })
+queue = Tina4::Queue.new(topic: "emails")
+queue.produce("emails", { to: "alice@example.com" })
 
-consumer = Tina4::Consumer.new(Tina4::Queue.new(topic: "emails"))
-consumer.each { |msg| send_email(msg.data) }
+queue.consume("emails") { |msg| send_email(msg.payload) }
 ```
 
 ### GraphQL
@@ -607,7 +606,7 @@ DATABASE_USERNAME=
 DATABASE_PASSWORD=
 TINA4_DEBUG=true                     # Enable dev toolbar, error overlay
 TINA4_LOG_LEVEL=ALL                  # ALL, DEBUG, INFO, WARNING, ERROR
-TINA4_LANGUAGE=en                    # en, fr, af, zh, ja, es
+TINA4_LOCALE=en                    # en, fr, af, zh, ja, es
 TINA4_SESSION_HANDLER=SessionFileHandler
 SWAGGER_TITLE=My API
 ```

data/lib/tina4/auth.rb

@@ -12,27 +12,130 @@ module Tina4
       def setup(root_dir = Dir.pwd)
         @keys_dir = File.join(root_dir, KEYS_DIR)
         FileUtils.mkdir_p(@keys_dir)
-        ensure_keys
+        ensure_keys unless use_hmac?
       end
 
-      def create_token(payload, expires_in: 3600)
-        ensure_keys
+      # ── HS256 helpers (stdlib only, no gem) ──────────────────────
+
+      # Returns true when SECRET env var is set and no RSA keys exist in .keys/
+      def use_hmac?
+        secret = ENV["SECRET"]
+        return false if secret.nil? || secret.empty?
+
+        # If RSA keys already exist on disk, prefer RS256 for backward compat
+        @keys_dir ||= File.join(Dir.pwd, KEYS_DIR)
+        !(File.exist?(File.join(@keys_dir, "private.pem")) &&
+          File.exist?(File.join(@keys_dir, "public.pem")))
+      end
+
+      def hmac_secret
+        ENV["SECRET"]
+      end
+
+      # Base64url-encode without padding (JWT spec)
+      def base64url_encode(data)
+        Base64.urlsafe_encode64(data, padding: false)
+      end
+
+      # Base64url-decode (handles missing padding)
+      def base64url_decode(str)
+        # Add back padding
+        remainder = str.length % 4
+        str += "=" * ((4 - remainder) % 4) if remainder != 0
+        Base64.urlsafe_decode64(str)
+      end
+
+      # Build a JWT using HS256 with Ruby's OpenSSL::HMAC (no gem needed)
+      def hmac_encode(claims, secret)
+        header = { "alg" => "HS256", "typ" => "JWT" }
+        segments = [
+          base64url_encode(JSON.generate(header)),
+          base64url_encode(JSON.generate(claims))
+        ]
+        signing_input = segments.join(".")
+        signature = OpenSSL::HMAC.digest("SHA256", secret, signing_input)
+        segments << base64url_encode(signature)
+        segments.join(".")
+      end
+
+      # Decode and verify a JWT signed with HS256. Returns the payload hash or nil.
+      def hmac_decode(token, secret)
+        parts = token.split(".")
+        return nil unless parts.length == 3
+
+        header_json = base64url_decode(parts[0])
+        header = JSON.parse(header_json)
+        return nil unless header["alg"] == "HS256"
+
+        # Verify signature
+        signing_input = "#{parts[0]}.#{parts[1]}"
+        expected_sig = OpenSSL::HMAC.digest("SHA256", secret, signing_input)
+        actual_sig = base64url_decode(parts[2])
+
+        # Constant-time comparison to prevent timing attacks
+        return nil unless OpenSSL.fixed_length_secure_compare(expected_sig, actual_sig)
+
+        payload = JSON.parse(base64url_decode(parts[1]))
+
+        # Check expiry
+        now = Time.now.to_i
+        return nil if payload["exp"] && now >= payload["exp"]
+        return nil if payload["nbf"] && now < payload["nbf"]
+
+        payload
+      rescue ArgumentError, JSON::ParserError, OpenSSL::HMACError
+        nil
+      end
+
+      # ── Token API (auto-selects HS256 or RS256) ─────────────────
+
+      def get_token(payload, expires_in: 3600)
         now = Time.now.to_i
         claims = payload.merge(
           "iat" => now,
           "exp" => now + expires_in,
           "nbf" => now
         )
-        require "jwt"
-        JWT.encode(claims, private_key, "RS256")
+
+        if use_hmac?
+          hmac_encode(claims, hmac_secret)
+        else
+          ensure_keys
+          require "jwt"
+          JWT.encode(claims, private_key, "RS256")
+        end
       end
 
 
-      def validate_token(token)
-        ensure_keys
-        require "jwt"
-        decoded = JWT.decode(token, public_key, true, algorithm: "RS256")
-        { valid: true, payload: decoded[0] }
+      def valid_token(token)
+        if use_hmac?
+          hmac_decode(token, hmac_secret)
+        else
+          ensure_keys
+          require "jwt"
+          decoded = JWT.decode(token, public_key, true, algorithm: "RS256")
+          decoded[0]
+        end
+      rescue JWT::ExpiredSignature
+        nil
+      rescue JWT::DecodeError
+        nil
+      end
+
+      def valid_token_detail(token)
+        if use_hmac?
+          payload = hmac_decode(token, hmac_secret)
+          if payload
+            { valid: true, payload: payload }
+          else
+            { valid: false, error: "Invalid or expired token" }
+          end
+        else
+          ensure_keys
+          require "jwt"
+          decoded = JWT.decode(token, public_key, true, algorithm: "RS256")
+          { valid: true, payload: decoded[0] }
+        end
       rescue JWT::ExpiredSignature
         { valid: false, error: "Token expired" }
       rescue JWT::DecodeError => e
@@ -53,34 +156,36 @@ module Tina4
 
 
       def get_payload(token)
-        require "jwt"
-        decoded = JWT.decode(token, nil, false)
-        decoded[0]
-      rescue JWT::DecodeError
+        parts = token.split(".")
+        return nil unless parts.length == 3
+
+        payload_json = base64url_decode(parts[1])
+        JSON.parse(payload_json)
+      rescue ArgumentError, JSON::ParserError
         nil
       end
 
       def refresh_token(token, expires_in: 3600)
-        result = validate_token(token)
-        return nil unless result[:valid]
+        payload = valid_token(token)
+        return nil unless payload
 
-        payload = result[:payload].reject { |k, _| %w[iat exp nbf].include?(k) }
-        create_token(payload, expires_in: expires_in)
+        payload = payload.reject { |k, _| %w[iat exp nbf].include?(k) }
+        get_token(payload, expires_in: expires_in)
       end
 
       def authenticate_request(headers)
         auth_header = headers["HTTP_AUTHORIZATION"] || headers["Authorization"] || ""
-        return { valid: false, error: "No authorization header" } unless auth_header =~ /\ABearer\s+(.+)\z/i
+        return nil unless auth_header =~ /\ABearer\s+(.+)\z/i
 
         token = Regexp.last_match(1)
 
         # API_KEY bypass — matches tina4_python behavior
         api_key = ENV["TINA4_API_KEY"] || ENV["API_KEY"]
         if api_key && !api_key.empty? && token == api_key
-          return { valid: true, payload: { "api_key" => true } }
+          return { "api_key" => true }
         end
 
-        validate_token(token)
+        valid_token(token)
       end
 
       def validate_api_key(provided, expected: nil)
@@ -107,15 +212,15 @@ module Tina4
           token = Regexp.last_match(1)
 
           # API_KEY bypass — matches tina4_python behavior
-          api_key = ENV["API_KEY"]
+          api_key = ENV["TINA4_API_KEY"] || ENV["API_KEY"]
           if api_key && !api_key.empty? && token == api_key
             env["tina4.auth"] = { "api_key" => true }
             return true
           end
 
-          result = validate_token(token)
-          if result[:valid]
-            env["tina4.auth"] = result[:payload]
+          payload = valid_token(token)
+          if payload
+            env["tina4.auth"] = payload
             true
           else
             false
@@ -129,6 +234,10 @@ module Tina4
         @default_secure_auth ||= bearer_auth
       end
 
+      # Legacy aliases
+      alias_method :create_token, :get_token
+      alias_method :validate_token, :valid_token_detail
+
       def private_key
         @private_key ||= OpenSSL::PKey::RSA.new(File.read(private_key_path))
       end
@@ -140,6 +249,8 @@ 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)
@@ -169,8 +280,7 @@ module Tina4
         return true if auth_header.empty?
 
         if auth_header =~ /\ABearer\s+(.+)\z/i
-          result = validate_token(Regexp.last_match(1))
-          result[:valid]
+          !valid_token(Regexp.last_match(1)).nil?
         else
           false
         end

data/lib/tina4/auto_crud.rb

@@ -21,10 +21,36 @@ module Tina4
         end
       end
 
+      # Build a sample request body from ORM field definitions.
+      def build_example(model_class)
+        example = {}
+        return example unless model_class.respond_to?(:field_definitions)
+
+        model_class.field_definitions.each do |name, opts|
+          next if opts[:primary_key] && opts[:auto_increment]
+
+          case opts[:type]
+          when :integer
+            example[name.to_s] = 0
+          when :numeric, :float, :decimal
+            example[name.to_s] = 0.0
+          when :boolean
+            example[name.to_s] = true
+          when :datetime
+            example[name.to_s] = "2024-01-01T00:00:00"
+          else
+            example[name.to_s] = "string"
+          end
+        end
+        example
+      end
+
       # Generate REST endpoints for a single model class
       def generate_routes_for(model_class, prefix: "/api")
         table = model_class.table_name
         pk = model_class.primary_key_field || :id
+        pretty_name = table.to_s.split("_").map(&:capitalize).join(" ")
+        example_body = build_example(model_class)
 
         # GET /api/{table} -- list all with pagination, filtering, sorting
         Tina4::Router.add_route("GET", "#{prefix}/#{table}", proc { |req, res|
@@ -63,7 +89,7 @@ module Tina4
           rescue => e
             res.json({ error: e.message }, status: 500)
           end
-        })
+        }, swagger_meta: { summary: "List all #{pretty_name}", tags: [table.to_s] })
 
         # GET /api/{table}/{id} -- get single record
         Tina4::Router.add_route("GET", "#{prefix}/#{table}/{id}", proc { |req, res|
@@ -78,7 +104,7 @@ module Tina4
           rescue => e
             res.json({ error: e.message }, status: 500)
           end
-        })
+        }, swagger_meta: { summary: "Get #{pretty_name} by ID", tags: [table.to_s] })
 
         # POST /api/{table} -- create record
         Tina4::Router.add_route("POST", "#{prefix}/#{table}", proc { |req, res|
@@ -93,6 +119,19 @@ module Tina4
           rescue => e
             res.json({ error: e.message }, status: 500)
           end
+        }, swagger_meta: {
+          summary: "Create #{pretty_name}",
+          tags: [table.to_s],
+          request_body: {
+            "description" => "#{pretty_name} data",
+            "required" => true,
+            "content" => {
+              "application/json" => {
+                "schema" => { "type" => "object" },
+                "example" => example_body
+              }
+            }
+          }
         })
 
         # PUT /api/{table}/{id} -- update record
@@ -118,6 +157,19 @@ module Tina4
           rescue => e
             res.json({ error: e.message }, status: 500)
           end
+        }, swagger_meta: {
+          summary: "Update #{pretty_name}",
+          tags: [table.to_s],
+          request_body: {
+            "description" => "#{pretty_name} data",
+            "required" => true,
+            "content" => {
+              "application/json" => {
+                "schema" => { "type" => "object" },
+                "example" => example_body
+              }
+            }
+          }
         })
 
         # DELETE /api/{table}/{id} -- delete record
@@ -137,7 +189,7 @@ module Tina4
           rescue => e
             res.json({ error: e.message }, status: 500)
           end
-        })
+        }, swagger_meta: { summary: "Delete #{pretty_name}", tags: [table.to_s] })
       end
 
       def clear!

data/lib/tina4/cli.rb

@@ -5,7 +5,7 @@ require "fileutils"
 
 module Tina4
   class CLI
-    COMMANDS = %w[init start migrate seed seed:create test version routes console generate ai help].freeze
+    COMMANDS = %w[init start migrate migrate:status migrate:rollback seed seed:create test version routes console generate ai help].freeze
 
     def self.start(argv)
       new.run(argv)
@@ -17,6 +17,8 @@ module Tina4
       when "init"       then cmd_init(argv)
       when "start"      then cmd_start(argv)
       when "migrate"    then cmd_migrate(argv)
+      when "migrate:status" then cmd_migrate_status(argv)
+      when "migrate:rollback" then cmd_migrate_rollback(argv)
       when "seed"       then cmd_seed(argv)
       when "seed:create" then cmd_seed_create(argv)
       when "test"       then cmd_test(argv)
@@ -180,6 +182,75 @@ module Tina4
       end
     end
 
+    # ── migrate:status ─────────────────────────────────────────────────────
+
+    def cmd_migrate_status(_argv)
+      require_relative "../tina4"
+      Tina4.initialize!(Dir.pwd)
+
+      db = Tina4.database
+      unless db
+        puts "No database configured. Set DATABASE_URL in your .env file."
+        return
+      end
+
+      migration = Tina4::Migration.new(db)
+      info = migration.status
+
+      puts "\nMigration Status"
+      puts "-" * 60
+
+      if info[:completed].any?
+        puts "\nCompleted:"
+        info[:completed].each { |name| puts "  [OK] #{name}" }
+      end
+
+      if info[:pending].any?
+        puts "\nPending:"
+        info[:pending].each { |name| puts "  [  ] #{name}" }
+      end
+
+      if info[:completed].empty? && info[:pending].empty?
+        puts "  No migrations found."
+      end
+
+      puts "-" * 60
+      puts "  Completed: #{info[:completed].length}  Pending: #{info[:pending].length}\n"
+    end
+
+    # ── migrate:rollback ───────────────────────────────────────────────────
+
+    def cmd_migrate_rollback(argv)
+      options = { steps: 1 }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: tina4ruby migrate:rollback [options]"
+        opts.on("-n", "--steps N", Integer, "Number of batches to rollback (default: 1)") { |v| options[:steps] = v }
+      end
+      parser.parse!(argv)
+
+      require_relative "../tina4"
+      Tina4.initialize!(Dir.pwd)
+
+      db = Tina4.database
+      unless db
+        puts "No database configured. Set DATABASE_URL in your .env file."
+        return
+      end
+
+      migration = Tina4::Migration.new(db)
+      results = migration.rollback(options[:steps])
+
+      if results.empty?
+        puts "Nothing to rollback."
+      else
+        results.each do |r|
+          status_icon = r[:status] == "rolled_back" ? "OK" : "FAIL"
+          puts "  [#{status_icon}] #{r[:name]}"
+        end
+        puts "Rolled back #{results.length} migration(s)."
+      end
+    end
+
     # ── seed ──────────────────────────────────────────────────────────────
 
     def cmd_seed(argv)
@@ -446,6 +517,8 @@ module Tina4
           init [NAME]        Initialize a new Tina4 project
           start              Start the Tina4 web server
           migrate            Run database migrations
+          migrate:status     Show migration status (completed and pending)
+          migrate:rollback   Rollback the last batch of migrations
           seed               Run all seed files in seeds/
           seed:create NAME   Create a new seed file
           test               Run inline tests
@@ -482,7 +555,7 @@ module Tina4
     # ── shared helpers ────────────────────────────────────────────────────
 
     def load_routes(root_dir)
-      route_dirs = %w[routes src/routes src/api api]
+      route_dirs = %w[src/routes routes src/api api src/orm orm]
       route_dirs.each do |dir|
         route_dir = File.join(root_dir, dir)
         next unless Dir.exist?(route_dir)

data/lib/tina4/cors.rb

@@ -52,7 +52,7 @@ module Tina4
         {
           origins: ENV["TINA4_CORS_ORIGINS"] || "*",
           methods: ENV["TINA4_CORS_METHODS"] || "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-          headers: ENV["TINA4_CORS_HEADERS"] || "Content-Type, Authorization, Accept",
+          headers: ENV["TINA4_CORS_HEADERS"] || "Content-Type,Authorization,X-Request-ID",
           max_age: ENV["TINA4_CORS_MAX_AGE"] || "86400",
           credentials: ENV["TINA4_CORS_CREDENTIALS"] || "false"
         }.freeze