tina4ruby 3.10.83 → 3.10.85

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7f1721eaefd19400dedcfdb298a6af42772aa824b9663a17d79bced2169161b
-  data.tar.gz: a712e6a50ea1ece57a4e4bc9e0e49c49dcb0f5e5c56471c1da26bd4f65c42d79
+  metadata.gz: 8e5521375e695d48e70b9f86d6a5c7abb62f9e887ee02ab975308bd51a99ee91
+  data.tar.gz: fd6c0fb85f91def5fbae4996752c70c36f184cfbec1f61cbc4d3949a8109a4fc
 SHA512:
-  metadata.gz: 8f50ab9dbaf48c592766f8b13debe1086e7288184a69849346fae318aa270a275c28fb28399eac9a834ba3c18fb884babefc8d1f860b9326c06fdba3623b4a43
-  data.tar.gz: ab1063c1b9402c3445ee4d75fdf98eab9342560e3d1689085879a48309fbe3a9761a0ee1759f517ae0641b82f46f801b6585244f45aadd83f7dbdddfd4c54f03
+  metadata.gz: 3d4a4d7db8e8fa3b87df07f19ab708ef9a3aebc00d40a5280adf7637869ef9ea40a4b1afce22aa3fd83bfdc6de073fb3eaa34c4842bdc5e6dedf2947758c6cd9
+  data.tar.gz: fdb5d4fd739f8926f8ec6cbed5d12691219d8938217bc7f3234fa8e1d166487ed8f12095c45e5dd128a3782412b1ef0685d85901e7972db05a0565e48baea4d6

data/lib/tina4/auth.rb

@@ -107,19 +107,19 @@ module Tina4
       end
 
 
-      def valid_token(token)
+      def valid_token(token) # -> bool
         if use_hmac?
-          hmac_decode(token, hmac_secret)
+          !hmac_decode(token, hmac_secret).nil?
         else
           ensure_keys
           require "jwt"
-          decoded = JWT.decode(token, public_key, true, algorithm: "RS256")
-          decoded[0]
+          JWT.decode(token, public_key, true, algorithm: "RS256")
+          true
         end
       rescue JWT::ExpiredSignature
-        nil
+        false
       rescue JWT::DecodeError
-        nil
+        false
       end
 
       def valid_token_detail(token)
@@ -174,9 +174,10 @@ module Tina4
       end
 
       def refresh_token(token, expires_in: 60)
-        payload = valid_token(token)
-        return nil unless payload
+        return nil unless valid_token(token)
 
+        payload = get_payload(token)
+        return nil unless payload
         payload = payload.reject { |k, _| %w[iat exp nbf].include?(k) }
         get_token(payload, expires_in: expires_in)
       end
@@ -193,7 +194,7 @@ module Tina4
           return { "api_key" => true }
         end
 
-        valid_token(token)
+        valid_token(token) ? get_payload(token) : nil
       end
 
       def validate_api_key(provided, expected: nil)
@@ -227,9 +228,8 @@ module Tina4
             return true
           end
 
-          payload = valid_token(token)
-          if payload
-            env["tina4.auth"] = payload
+          if valid_token(token)
+            env["tina4.auth"] = get_payload(token)
             true
           else
             false
@@ -287,7 +287,7 @@ module Tina4
         return true if auth_header.empty?
 
         if auth_header =~ /\ABearer\s+(.+)\z/i
-          !valid_token(Regexp.last_match(1)).nil?
+          valid_token(Regexp.last_match(1))
         else
           false
         end

data/lib/tina4/middleware.rb

@@ -307,8 +307,7 @@ module Tina4
         if auth_header.start_with?("Bearer ")
           bearer_token = auth_header[7..].strip
           unless bearer_token.empty?
-            payload = Tina4::Auth.valid_token(bearer_token)
-            return [request, response] if payload
+            return [request, response] if Tina4::Auth.valid_token(bearer_token)
           end
         end
 
@@ -344,14 +343,13 @@ module Tina4
         end
 
         # Validate the token
-        payload = Tina4::Auth.valid_token(token.to_s)
-
-        if payload.nil?
+        unless Tina4::Auth.valid_token(token.to_s)
           response.json({ error: "CSRF_INVALID", message: "Invalid or missing form token" }, 403)
           return [request, response]
         end
 
         # Session binding — if token has session_id, verify it matches
+        payload = Tina4::Auth.get_payload(token.to_s) || {}
         token_session_id = payload["session_id"]
         if token_session_id
           current_session_id = nil

data/lib/tina4/migration.rb

@@ -87,6 +87,23 @@ module Tina4
       filepath
     end
 
+    # Get list of applied migration records (public alias for completed_migrations)
+    def get_applied
+      completed_migrations
+    end
+
+    # Get list of pending migration filenames (public alias for pending_migrations)
+    def get_pending
+      pending_migrations.map { |f| File.basename(f) }
+    end
+
+    # Get all migration files on disk, excluding .down files
+    def get_files
+      migration_files = Dir.glob(File.join(@migrations_dir, "*.sql")).reject { |f| f.end_with?(".down.sql") }
+      migration_files += Dir.glob(File.join(@migrations_dir, "*.rb"))
+      migration_files.map { |f| File.basename(f) }.sort
+    end
+
     private
 
     # Resolve migrations directory: prefer src/migrations, fall back to migrations/

data/lib/tina4/orm.rb

@@ -79,7 +79,7 @@ module Tina4
       end
 
       # has_one :profile, class_name: "Profile", foreign_key: "user_id"
-      def has_one(name, class_name: nil, foreign_key: nil)
+      def has_one(name, class_name: nil, foreign_key: nil) # -> nil
         relationship_definitions[name] = {
           type: :has_one,
           class_name: class_name || name.to_s.split("_").map(&:capitalize).join,
@@ -92,7 +92,7 @@ module Tina4
       end
 
       # has_many :posts, class_name: "Post", foreign_key: "user_id"
-      def has_many(name, class_name: nil, foreign_key: nil)
+      def has_many(name, class_name: nil, foreign_key: nil) # -> nil
         relationship_definitions[name] = {
           type: :has_many,
           class_name: class_name || name.to_s.sub(/s$/, "").split("_").map(&:capitalize).join,
@@ -105,7 +105,7 @@ module Tina4
       end
 
       # belongs_to :user, class_name: "User", foreign_key: "user_id"
-      def belongs_to(name, class_name: nil, foreign_key: nil)
+      def belongs_to(name, class_name: nil, foreign_key: nil) # -> nil
         relationship_definitions[name] = {
           type: :belongs_to,
           class_name: class_name || name.to_s.split("_").map(&:capitalize).join,
@@ -123,7 +123,7 @@ module Tina4
       #   results = User.query.where("active = ?", [1]).order_by("name").get
       #
       # @return [Tina4::QueryBuilder]
-      def query
+      def query # -> QueryBuilder
         QueryBuilder.from(table_name, db: db)
       end
 
@@ -136,7 +136,7 @@ module Tina4
       #   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)
+      def find(filter = {}, limit: 100, offset: 0, order_by: nil, include: nil, **extra_filter) # -> list[Self]
         # Integer or string-digit argument → primary key lookup (returns single record or nil)
         return find_by_id(filter) if filter.is_a?(Integer)
 
@@ -243,7 +243,7 @@ module Tina4
         end
       end
 
-      def where(conditions, params = [], include: nil)
+      def where(conditions, params = [], include: nil) # -> list[Self]
         sql = "SELECT * FROM #{table_name}"
         if soft_delete
           sql += " WHERE (#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0) AND (#{conditions})"
@@ -256,7 +256,7 @@ module Tina4
         instances
       end
 
-      def all(limit: nil, offset: nil, order_by: nil, include: nil)
+      def all(limit: nil, offset: nil, order_by: nil, include: nil) # -> list[Self]
         sql = "SELECT * FROM #{table_name}"
         if soft_delete
           sql += " WHERE #{soft_delete_field} IS NULL OR #{soft_delete_field} = 0"
@@ -268,19 +268,19 @@ module Tina4
         instances
       end
 
-      def select(sql, params = [], limit: nil, offset: nil, include: nil)
+      def select(sql, params = [], limit: nil, offset: nil, include: nil) # -> list[Self]
         results = db.fetch(sql, params, limit: limit, offset: offset)
         instances = results.map { |row| from_hash(row) }
         eager_load(instances, include) if include
         instances
       end
 
-      def select_one(sql, params = [], include: nil)
+      def select_one(sql, params = [], include: nil) # -> Self | nil
         results = select(sql, params, limit: 1, include: include)
         results.first
       end
 
-      def count(conditions = nil, params = [])
+      def count(conditions = nil, params = []) # -> int
         sql = "SELECT COUNT(*) as cnt FROM #{table_name}"
         where_parts = []
         if soft_delete
@@ -292,25 +292,48 @@ module Tina4
         result[:cnt].to_i
       end
 
-      def create(attributes = {})
+      def create(attributes = {}) # -> Self
         instance = new(attributes)
         instance.save
         instance
       end
 
-      def find_or_fail(id)
+      def find_or_fail(id) # -> Self
         result = find(id)
         raise "#{name} with #{primary_key_field || :id}=#{id} not found" if result.nil?
         result
       end
 
-      def with_trashed(conditions = "1=1", params = [], limit: 20, offset: 0)
+      # Return true if a record with the given primary key exists.
+      def exists(pk_value) # -> bool
+        find(pk_value) != nil
+      end
+
+      # SQL query with in-memory result caching.
+      # Results are cached by (class, sql, params, limit, offset) for +ttl+ seconds.
+      def cached(sql, params = [], ttl: 60, limit: 20, offset: 0, include: nil) # -> list[Self]
+        @_query_cache ||= Tina4::QueryCache.new(default_ttl: ttl, max_size: 500)
+        cache_key = Tina4::QueryCache.query_key("#{name}:#{sql}", params + [limit, offset])
+        hit = @_query_cache.get(cache_key)
+        return hit unless hit.nil?
+
+        results = select(sql, params, limit: limit, offset: offset, include: include)
+        @_query_cache.set(cache_key, results, ttl: ttl, tags: [name])
+        results
+      end
+
+      # Clear all cached query results for this model.
+      def clear_cache # -> nil
+        @_query_cache&.clear_tag(name)
+      end
+
+      def with_trashed(conditions = "1=1", params = [], limit: 20, offset: 0) # -> list[Self]
         sql = "SELECT * FROM #{table_name} WHERE #{conditions}"
         results = db.fetch(sql, params, limit: limit, offset: offset)
         results.map { |row| from_hash(row) }
       end
 
-      def create_table
+      def create_table # -> bool
         return true if db.table_exists?(table_name)
 
         type_map = {
@@ -351,7 +374,7 @@ module Tina4
         true
       end
 
-      def scope(name, filter_sql, params = [])
+      def scope(name, filter_sql, params = []) # -> nil
         define_singleton_method(name) do |limit: 20, offset: 0|
           where(filter_sql, params)
         end
@@ -371,7 +394,7 @@ module Tina4
       end
 
       # Find a single record by primary key. Returns instance or nil.
-      def find_by_id(id)
+      def find_by_id(id) # -> Self | nil
         pk = primary_key_field || :id
         sql = "SELECT * FROM #{table_name} WHERE #{pk} = ?"
         if soft_delete
@@ -416,7 +439,7 @@ module Tina4
       end
     end
 
-    def save
+    def save # -> Self | bool
       @errors = []
       @relationship_cache = {} # Clear relationship cache on save
       validate_fields
@@ -448,7 +471,7 @@ module Tina4
       false
     end
 
-    def delete
+    def delete # -> bool
       pk = self.class.primary_key_field || :id
       pk_value = __send__(pk)
       return false unless pk_value
@@ -468,7 +491,7 @@ module Tina4
       true
     end
 
-    def force_delete
+    def force_delete # -> bool
       pk = self.class.primary_key_field || :id
       pk_value = __send__(pk)
       raise "Cannot delete: no primary key value" unless pk_value
@@ -480,7 +503,7 @@ module Tina4
       true
     end
 
-    def restore
+    def restore # -> bool
       raise "Model does not support soft delete" unless self.class.soft_delete
 
       pk = self.class.primary_key_field || :id
@@ -498,7 +521,7 @@ module Tina4
       true
     end
 
-    def validate
+    def validate # -> list[str]
       errors = []
       self.class.field_definitions.each do |name, opts|
         value = __send__(name)
@@ -519,7 +542,7 @@ module Tina4
     #   orm.load("id = 1")            — filter string
     #
     # Returns true if a record was found, false otherwise.
-    def load(filter = nil, params = [], include: nil)
+    def load(filter = nil, params = [], include: nil) # -> bool
       @relationship_cache = {}
       table = self.class.table_name
 
@@ -557,7 +580,7 @@ module Tina4
 
     # Convert to hash using Ruby attribute names.
     # Optionally include relationships via the include keyword.
-    def to_h(include: nil)
+    def to_h(include: nil) # -> dict
       hash = {}
       self.class.field_definitions.each_key do |name|
         hash[name] = __send__(name)
@@ -594,13 +617,13 @@ module Tina4
     alias to_assoc to_h
     alias to_object to_h
 
-    def to_array
+    def to_array # -> list
       to_h.values
     end
 
     alias to_list to_array
 
-    def to_json(include: nil, **_args)
+    def to_json(include: nil, **_args) # -> str
       JSON.generate(to_h(include: include))
     end
 

data/lib/tina4/queue.rb

@@ -36,49 +36,49 @@ module Tina4
     end
 
     # Pop the next available job. Returns Job or nil.
-    def pop
+    def pop # -> Job|None
       @backend.dequeue(@topic)
     end
 
     # Clear all pending jobs from this queue's topic. Returns count removed.
-    def clear
+    def clear # -> int
       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
+    def failed # -> list[dict]
       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)
+    # Retry failed jobs on this queue's topic. Returns true if re-queued.
+    def retry(delay_seconds = 0) # -> bool
       return false unless @backend.respond_to?(:retry_job)
-      @backend.retry_job(@topic, job_id, delay_seconds: delay_seconds)
+      @backend.retry_job(@topic, delay_seconds: delay_seconds)
     end
 
     # Get dead letter jobs — messages that exceeded max retries.
-    def dead_letters
+    def dead_letters # -> list[dict]
       return [] unless @backend.respond_to?(:dead_letters)
       @backend.dead_letters(@topic, max_retries: @max_retries)
     end
 
     # Delete messages by status (completed, failed, dead).
-    def purge(status)
+    def purge(status) # -> int
       return 0 unless @backend.respond_to?(:purge)
       @backend.purge(@topic, status)
     end
 
     # Re-queue failed messages (under max_retries) back to pending.
     # Returns the number of jobs re-queued.
-    def retry_failed
+    def retry_failed # -> int
       return 0 unless @backend.respond_to?(:retry_failed)
       @backend.retry_failed(@topic, max_retries: @max_retries)
     end
 
     # Produce a message onto a topic. Convenience wrapper around push().
-    def produce(topic, payload, priority: 0)
+    def produce(topic, payload, priority = 0)
       message = Job.new(topic: topic, payload: payload, priority: priority)
       @backend.enqueue(message)
       message

data/lib/tina4/queue_backends/lite_backend.rb

@@ -218,28 +218,32 @@ module Tina4
         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)
+      # Retry all dead letter jobs for this topic. Returns true if any were re-queued.
+      def retry_job(topic, 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
+        count = 0
+
+        Dir.glob(File.join(@dead_letter_dir, "*.json")).each do |file|
+          data = JSON.parse(File.read(file))
+          next unless data["topic"] == topic.to_s
+
+          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)
+          count += 1
+        rescue JSON::ParserError
+          next
+        end
+
+        count > 0
       end
 
       private

data/lib/tina4/rack_app.rb

@@ -176,11 +176,10 @@ module Tina4
         if api_key && !api_key.empty? && token == api_key
           env["tina4.auth_payload"] = { "api_key" => true }
         elsif token
-          payload = Tina4::Auth.valid_token(token)
-          unless payload
+          unless Tina4::Auth.valid_token(token)
             return [401, { "content-type" => "application/json" }, [JSON.generate({ error: "Unauthorized" })]]
           end
-          env["tina4.auth_payload"] = payload
+          env["tina4.auth_payload"] = Tina4::Auth.get_payload(token)
         else
           return [401, { "content-type" => "application/json" }, [JSON.generate({ error: "Unauthorized" })]]
         end

data/lib/tina4/session.rb

@@ -114,9 +114,10 @@ module Tina4
       @handler.gc(max_age) if @handler.respond_to?(:gc)
     end
 
-    def cookie_header
+    def cookie_header(cookie_name = nil)
+      name = cookie_name || @options[:cookie_name]
       samesite = ENV["TINA4_SESSION_SAMESITE"] || "Lax"
-      "#{@options[:cookie_name]}=#{@id}; Path=/; HttpOnly; SameSite=#{samesite}; Max-Age=#{@options[:max_age]}"
+      "#{name}=#{@id}; Path=/; HttpOnly; SameSite=#{samesite}; Max-Age=#{@options[:max_age]}"
     end
 
     private
@@ -223,9 +224,9 @@ module Tina4
       @session.gc(max_age)
     end
 
-    def cookie_header
+    def cookie_header(cookie_name = nil)
       ensure_loaded
-      @session.cookie_header
+      @session.cookie_header(cookie_name)
     end
 
     def to_hash

data/lib/tina4/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.10.83
+  version: 3.10.85
 platform: ruby
 authors:
 - Tina4 Team