svelte-on-rails 22.2.0 → 22.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a32126c57f42015b2fae36849a77266d174dfc6234a5958c924b490e4c1efc47
-  data.tar.gz: b264887e056b7d3aeb763923d1f20eccdab81000bc1c7dae63b7c909397157c0
+  metadata.gz: e4e1180e9510fa0b8592b0b17be5ae1f75348124861184022648f2ec6b96865d
+  data.tar.gz: 737ff843db6d9fe9ae04d34fd24b214089368d2b34357ac0e64a14ff90c13d52
 SHA512:
-  metadata.gz: ec6ad182cd5a2f06c654017f2ddbc81fe07b07498339262b0ec145d7fbaa815d12abef5a681930080d8edaee57e536f036399e5df011c8e3d3413ecea9b0a5f7
-  data.tar.gz: e67beb89b3a4ed77bdb3d7cc39f54596769c1b9cd25d12b7db7341cf860176d0b9a633b6fba4e4703a2a48d42509a1b18a977345b0a91214cefe556c760766b2
+  metadata.gz: 769b3c284cdddd35fb86895a29a6ae3a7bce52f501cb689856c1d166892fd360a264eafe274f2cc41944ec57d1a044d25c2c3a1934149ce9e0d1afb972f4501a
+  data.tar.gz: 2d067a4983fb063fc1e38a1a68e235050d405dad829bea0727ceed9a6d0a35752909d2ae2aba99177e73af21ef01e0cd848d51c30612838ea48fda5163c95c90

data/lib/svelte-on-rails.rb

@@ -18,6 +18,7 @@ require "svelte_on_rails/lib/to_svelte_values"
 require "svelte_on_rails/lib/to_svelte_support"
 require "svelte_on_rails/lib/to_svelte_translations"
 require "svelte_on_rails/lib/cache_warmer"
+require "svelte_on_rails/lib/boot_context"
 
 # installer
 require 'svelte_on_rails/installer/utils'

data/lib/svelte_on_rails/configuration.rb

@@ -44,14 +44,9 @@ module SvelteOnRails
 
       if @configs[:redis_cache_store]
         store = @configs[:redis_cache_store]
-        if store['expires_in'].is_a?(String)
-          @configs[:redis_cache_store]['expires_in'] = parse_duration(
-            store['expires_in']
-          )
-        end
         @redis_namespace = store[:namespace]
       end
-      @redis_namespace ||= "svelte-on-rails:#{Rails.env rescue 'no-env'}"
+      @redis_namespace ||= "#{app_name}:svelte-on-rails:#{Rails.env rescue 'no-env'}"
       @configs[:skip_ssr_header] ||= 'X-Turbo-Request-ID'
       if defined? Redis
         @redis_instance = Redis.new(url: redis_cache_store[:url])
@@ -60,6 +55,7 @@ module SvelteOnRails
       validate_serialized_configs
       custom_config_validations
       validate_npm_packages
+      process_configs
     end
 
     def set_config_defaults
@@ -175,11 +171,18 @@ module SvelteOnRails
       nil
     end
 
+    def process_configs
+      ex = @configs[:cache_expires_in]
+      if ex
+        @configs[:cache_expires_in] = ex.split('.').first.to_i.send(ex.split('.').last)
+      end
+    end
+
     private
 
     def redis_cache_store_configs
       if defined?(Rails.application) && Rails.application.config.cache_store.is_a?(Array) && Rails.application.config.cache_store.first == :redis_cache_store
-        { redis_cache_store: Rails.application.config.cache_store.second.stringify_keys }
+        { redis_cache_store: Rails.application.config.cache_store.second.deep_symbolize_keys }
       else
         {}
       end
@@ -228,7 +231,7 @@ module SvelteOnRails
         ssr: { options_required: [:auto, true, false] },
         watch_changes: { options_optional: [true, false] },
 
-        redis_cache_store: { hash_of_strings_optional: [:url, :namespace, :expires_in] },
+        redis_cache_store: { hash_of_strings_optional: [:url, :namespace] },
         turbo_stream: { hash_of_strings_optional: [:target_html_id, :channel] },
         action_cable: { hash_of_strings_optional: [:channel] },
 
@@ -245,6 +248,11 @@ module SvelteOnRails
         elsif k == :default_components_root
           available_keys = ['components_subdir'] + @configs[:extra_component_paths].to_a
           raise "[SOR] Invalid configuration: #{k} must be one of: [«#{available_keys.join('», «')}»]" unless available_keys.include?(v)
+        elsif k == :cache_expires_in
+          reg = /^[0-9]+\.(minutes|hours|days)$/
+          unless v.match(reg)
+            raise "#{k} must match #{reg}"
+          end
         elsif validation[:required]
           if validation[:required] == :string
             raise "[SOR] Missing configuration: #{k} must contain a string" if !v.present? || !v.is_a?(String)
@@ -262,6 +270,8 @@ module SvelteOnRails
           raise "[SOR] Invalid configuration: #{k} must be one of #{validation[:options_optional]}" unless validation[:options_optional].include?(v)
         elsif validation[:hash_of_strings_optional]
 
+          raise "[SOR] #{k} is empty. Either remove this key or provide a hash" unless v.present?
+
           _available_keys = validation[:hash_of_strings_optional]
           v.each do |_k, _v|
             raise "[SOR] Invalid configuration: #{k}/#{_k} («#{_v}» / #{_v.class}) must be a string" unless _v.is_a?(String)
@@ -367,5 +377,12 @@ module SvelteOnRails
       end
     end
 
+    def app_name
+      # Same logic Rails uses internally for e.g. cache_store default namespace
+      Rails.application.class&.module_parent_name.to_s[0..30].underscore.presence || 'app'
+    rescue StandardError
+      'app'
+    end
+
   end
 end

data/lib/svelte_on_rails/lib/boot_context.rb

@@ -0,0 +1,98 @@
+module SvelteOnRails
+  module BootContext
+    module_function
+
+    # We deliberately use a BLACKLIST + program-name check, not a whitelist of
+    # loaded constants. Reason: `puma` is typically in the app's Gemfile default
+    # group, so `defined?(::Puma::Launcher)` is truthy even inside `rails console`
+    # or `rails assets:precompile`.
+    def serving_http?
+      # Explicit overrides for tests / edge cases:
+      return true  if ENV["SVELTE_ON_RAILS_FORCE_SSR"] == "1"
+      return false if ENV["SVELTE_ON_RAILS_DISABLE_SSR"] == "1"
+
+      return false if rake_task?
+      return false if rails_console?
+      return false if rails_runner?
+      return false if rails_dbconsole?
+      return false if rails_generator?
+      return false if test_runner?
+
+      # Positive signal: `rails server` sets this constant during command dispatch.
+      return true if defined?(Rails::Server)
+
+      # Positive signal: launched directly via a server binary (bundle exec puma,
+      # rackup, unicorn, falcon, passenger). $PROGRAM_NAME is set by the launcher
+      # before it requires the app, so this is reliable.
+      return true if server_program_name?
+
+      # Default: assume this is NOT an HTTP-serving context. Better to be silent
+      # than to spawn an unwanted Node process; users can force with the ENV var.
+      false
+    end
+
+    def description
+      return "rake tasks: #{Rake.application.top_level_tasks.join(', ')}" if rake_task?
+      return "rails console"                                              if rails_console?
+      return "rails runner"                                               if rails_runner?
+      return "rails dbconsole"                                            if rails_dbconsole?
+      return "rails generator"                                            if rails_generator?
+      return "test runner (#{test_runner_name})"                          if test_runner?
+      return "rails server"                                               if defined?(Rails::Server)
+      "program=#{File.basename($PROGRAM_NAME)}"
+    end
+
+    # --- detectors -----------------------------------------------------------
+
+    def rake_task?
+      defined?(Rake) && Rake.respond_to?(:application) && Rake.application.top_level_tasks.any?
+    end
+
+    def rails_console?
+      defined?(Rails::Console) ||
+        program_basename == "irb" ||
+        (defined?(IRB) && $PROGRAM_NAME.to_s.include?("irb"))
+    end
+
+    def rails_runner?
+      defined?(Rails::Command::RunnerCommand) &&
+        Rails::Command.const_defined?(:RunnerCommand) &&
+        current_rails_command?("runner")
+    end
+
+    def rails_dbconsole?
+      defined?(Rails::DBConsole) || current_rails_command?("dbconsole")
+    end
+
+    def rails_generator?
+      defined?(Rails::Generators) && current_rails_command?("generate", "destroy", "new")
+    end
+
+    def test_runner?
+      !test_runner_name.nil?
+    end
+
+    def test_runner_name
+      return "rspec"    if $PROGRAM_NAME.to_s.include?("rspec")
+      return "minitest" if defined?(Minitest) && Minitest.respond_to?(:run) && !defined?(Rails::Server)
+      return "cucumber" if $PROGRAM_NAME.to_s.include?("cucumber")
+      nil
+    end
+
+    def server_program_name?
+      %w[puma rackup unicorn unicorn_rails falcon passenger].include?(program_basename)
+    end
+
+    def program_basename
+      File.basename($PROGRAM_NAME.to_s)
+    end
+
+    # `rails <command>` sets ARGV[0] to the command name before Rails::Command
+    # dispatches. This is stable across Rails 6/7/8.
+    def current_rails_command?(*names)
+      argv0 = (defined?(ARGV) && ARGV.first) || nil
+      return false unless argv0
+      names.include?(argv0.to_s)
+    end
+  end
+end

data/lib/svelte_on_rails/lib/view_helper_support.rb

@@ -5,7 +5,14 @@ module SvelteOnRails
     class ViewHelperSupport
 
       UNCACHED_PROPS_PLACEHOLDER = "**Uncached Props are available only after hydration**"
-      RENDER_OPTIONS = { ssr: [true, false, :auto], hydrate: :bool, debug: :bool, cache_key: :string_array, expires_in: :integer, cached: :bool }
+      RENDER_OPTIONS = {
+        ssr: [:oneof, [true, false, :auto]],
+        hydrate: [:oneof, [true, false]],
+        debug: [:oneof, [true, false]],
+        cache_key: [:typeof, [String, Array]],
+        cache_expires_in: [:typeof, [Integer, ActiveSupport::Duration]],
+        cached: [:oneof, [true, false]]
+      }
       attr_reader :conf
 
       def initialize(
@@ -191,7 +198,7 @@ module SvelteOnRails
                 @conf.debug_log(debug?, component_paths[:name], "rendered and stored to cache (key: «#{cache_key}»)") do
                   r = view_context.instance_eval(&block)
                   unless @skip_caching
-                    @conf.redis_instance.set(cache_key, r)
+                    @conf.redis_instance.set(cache_key, r, ex: redis_expiration_seconds)
                   end
                   r
                 end
@@ -289,18 +296,17 @@ module SvelteOnRails
           raise "Unknown options: #{@options.keys - RENDER_OPTIONS.keys}. Valid options are: :#{RENDER_OPTIONS.keys.join(', :')}"
         end
         @options.each do |k, v|
-          _v = RENDER_OPTIONS[k]
-          if _v == :bool
-            unless [true, false].include?(v)
-              raise "[SOR] Invalid option: :#{k} must be true or false (boolean)."
-            end
-          elsif _v == :string_array
-            unless [String, Array].include?(v.class)
-              raise "[SOR] Invalid option: :#{k} must be a string or Array (list of strings)."
+          validation = RENDER_OPTIONS[k]
+          _v_type = validation.first
+          _v_opts = validation.second
+
+          if validation.first == :oneof
+            unless validation.second.include? v
+              raise "[SOR] Invalid option: :#{k} must be one of #{validation.second.join(', ')}"
             end
-          elsif _v.is_a?(Array)
-            unless _v.include?(v)
-              raise "[SOR] Invalid option: :#{k} must be one of #{_v.join(', ')}"
+          elsif validation.first == :typeof
+            unless validation.second.include? v.class
+              raise "[SOR] Invalid option: :#{k} must be one of #{validation.second.join(', ')}"
             end
           else
             raise "[SOR] Unknown validation for option"
@@ -337,16 +343,17 @@ module SvelteOnRails
         @cache_key = begin
                        fingerprint = (@conf.watch_changes? ? @conf.fingerprint(component_paths[:path], debug?, component_paths[:name]) : '')
 
-                       cache_key_raw = @view_dir + @component_name + @options.to_s +
+                       cache_key_raw = @options.to_s +
                                        @cached_props.to_s + fingerprint + @options[:cache_key].to_s +
                                        (@cached_props.key?(:_uncached) ? "" : @html_options.to_s)
 
-                       "#{@conf.redis_namespace}:#{Digest::XXH64.hexdigest(cache_key_raw)}"
+                       "#{@conf.redis_namespace}:#{@component_name.gsub('/','-')}:#{Digest::XXH64.hexdigest(cache_key_raw)}"
                      end
       end
 
       def redis_expiration_seconds
-        (conf.redis_cache_store[:expires_in] || @options[:expires_in] || 1.hour).to_i
+        ex = @options[:cache_expires_in] || conf.configs[:cache_expires_in] || 3.days
+        ex.to_i
       end
 
     end

data/lib/svelte_on_rails/railtie.rb

@@ -13,12 +13,14 @@ module SvelteOnRails
 
     # Spawn the Node SSR child process only when we're really about to serve
     # HTTP. `after_initialize` runs at the end of boot, so Puma/Unicorn/etc.
-    # are already loaded and the detection in `start_ssr_server?` is reliable.
+    # are already loaded and the detection in `serving_http?` is reliable.
     initializer "svelte-on-rails.initialize_ssr_client" do |app|
       app.config.after_initialize do
 
-        if defined?(Rake) && Rake.respond_to?(:application) && Rake.application.top_level_tasks.any?
-          SvelteOnRails::Lib::Utils.ssr_server_log("Skipping svelte-on-rails SSR-Server because of top level task: #{Rake.application.top_level_tasks.join(', ')}")
+        if !SvelteOnRails::BootContext.serving_http?
+          SvelteOnRails::Lib::Utils.ssr_server_log(
+            "Skipping svelte-on-rails SSR-Server (#{SvelteOnRails::BootContext.description})"
+          )
           $stdout.flush
         elsif SvelteOnRails::Configuration.instance.configs[:ssr]
           SvelteOnRails::SsrClient.instance
@@ -51,7 +53,7 @@ module SvelteOnRails
 
     rake_tasks do
       load File.expand_path("../../tasks/svelte_on_rails_tasks.rake", __FILE__)
+      load File.expand_path("../../tasks/cache_tasks.rake", __FILE__)
     end
-
   end
 end

data/lib/svelte_on_rails/view_helpers.rb

@@ -143,15 +143,18 @@ module SvelteOnRails
     end
 
     def calling_view_dir
-      rails_views_path = Rails.root.join('app', 'views').to_s
-      raw_path_full = caller_locations.find do |loc|
-        loc.to_s.include?(rails_views_path)
-      end.to_s
-
-      if raw_path_full.present?
-        raw_path = raw_path_full.split(/:[0-9]+:in/).first
-        File.dirname(raw_path[(rails_views_path.length + 1)..-1])
-      end.to_s
+      rails_views_path = SvelteOnRails::ViewHelpers.rails_views_path
+      prefix_len = rails_views_path.length + 1
+
+      # Walk only a bounded slice of the stack; use loc.path (no string formatting).
+      loc = caller_locations(1, 60)&.find { |l| l.path&.start_with?(rails_views_path) }
+      return ''.freeze unless loc
+
+      File.dirname(loc.path[prefix_len..-1])
+    end
+
+    def self.rails_views_path
+      @rails_views_path ||= Rails.root.join('app', 'views').to_s
     end
 
   end

data/lib/tasks/cache_tasks.rake

@@ -0,0 +1,156 @@
+namespace :svelte_on_rails do
+  namespace :cache do
+
+    desc "Delete all svelte-on-rails cache keys from Redis (scoped to the configured redis_namespace)"
+    task clear: :environment do
+      conf = SvelteOnRails::Configuration.instance
+      redis = conf.redis_instance
+      namespace = conf.redis_namespace
+
+      unless redis
+        warn "svelte_on_rails:clear_cache — no redis_instance configured, nothing to do."
+        next
+      end
+
+      if Rails.env.production? && ENV["FORCE"] != "1"
+        print "You are about to delete all keys matching «#{namespace}:*» in PRODUCTION. Continue? (y/N) "
+        answer = STDIN.gets.to_s.strip.downcase
+        unless %w[y yes].include?(answer)
+          puts "Aborted."
+          next
+        end
+      end
+
+      pattern = "#{namespace}:*"
+      cursor = "0"
+      total_deleted = 0
+      batches = 0
+
+      puts "Scanning Redis for keys matching «#{pattern}» ..."
+
+      loop do
+        cursor, keys = redis.scan(cursor, match: pattern, count: 500)
+        if keys.any?
+          # UNLINK is non-blocking on Redis >= 4; fall back to DEL if not available.
+          deleted = begin
+                      redis.unlink(*keys)
+                    rescue Redis::CommandError
+                      redis.del(*keys)
+                    end
+          total_deleted += deleted
+          batches += 1
+        end
+        break if cursor == "0"
+      rescue => e
+        warn "svelte_on_rails:clear_cache — error during scan/delete: #{e.class}: #{e.message}"
+        break
+      end
+
+      puts "svelte_on_rails:clear_cache — deleted #{total_deleted} key(s) in #{batches} batch(es) under «#{pattern}»."
+    end
+
+    desc "Show all svelte-on-rails Redis keys with their memory footprint (scoped to redis_namespace). Env: LIMIT=n, SORT=size|key, PATTERN=extra-glob"
+    task show: :environment do
+      conf = SvelteOnRails::Configuration.instance
+      redis = conf.redis_instance
+      namespace = conf.redis_namespace
+
+      unless redis
+        warn "svelte_on_rails:show_cache — no redis_instance configured, nothing to show."
+        next
+      end
+
+      extra = ENV["PATTERN"].to_s.strip
+      pattern = extra.empty? ? "#{namespace}:*" : "#{namespace}:*#{extra}*"
+      limit = ENV["LIMIT"].to_s =~ /\A\d+\z/ ? ENV["LIMIT"].to_i : nil
+      sort_by = %w[size key].include?(ENV["SORT"]) ? ENV["SORT"] : "size"
+
+      puts "Scanning Redis for keys matching «#{pattern}» ..."
+
+      entries = [] # [{ key:, bytes:, ttl:, type: }]
+      cursor = "0"
+
+      loop do
+        cursor, keys = redis.scan(cursor, match: pattern, count: 500)
+
+        if keys.any?
+          # Pipeline MEMORY USAGE / TTL / TYPE for the whole batch.
+          results = redis.pipelined do |p|
+            keys.each do |k|
+              p.call(["MEMORY", "USAGE", k])
+              p.ttl(k)
+              p.type(k)
+            end
+          end
+
+          keys.each_with_index do |k, i|
+            bytes = results[i * 3]
+            ttl = results[i * 3 + 1]
+            type = results[i * 3 + 2]
+            entries << { key: k, bytes: bytes.to_i, ttl: ttl.to_i, type: type }
+          end
+        end
+
+        break if cursor == "0"
+      rescue => e
+        warn "svelte_on_rails:show_cache — error during scan: #{e.class}: #{e.message}"
+        break
+      end
+
+      if entries.empty?
+        puts "No keys found under «#{pattern}»."
+        next
+      end
+
+      entries.sort_by! { |e| sort_by == "size" ? -e[:bytes] : e[:key] }
+      shown = limit ? entries.first(limit) : entries
+
+      key_w = [shown.map { |e| e[:key].length }.max, 3].max
+      size_w = [shown.map { |e| human_bytes(e[:bytes]).length }.max, 4].max
+      ttl_w = [shown.map { |e| ttl_str(e[:ttl]).length }.max, 3].max
+      type_w = [shown.map { |e| e[:type].to_s.length }.max, 4].max
+
+      header = format("%-#{key_w}s  %#{size_w}s  %#{ttl_w}s  %-#{type_w}s", "KEY", "SIZE", "TTL", "TYPE")
+      puts header
+      puts "-" * header.length
+
+      shown.each do |e|
+        puts format(
+               "%-#{key_w}s  %#{size_w}s  %#{ttl_w}s  %-#{type_w}s",
+               e[:key], human_bytes(e[:bytes]), ttl_str(e[:ttl]), e[:type]
+             )
+      end
+
+      total_bytes = entries.sum { |e| e[:bytes] }
+      puts "-" * header.length
+      puts "Total: #{entries.size} key(s), #{human_bytes(total_bytes)} in RAM" \
+             "#{limit && entries.size > limit ? " (showing top #{limit} by #{sort_by})" : ""}"
+    end
+  end
+end
+
+# Helpers used by svelte_on_rails:show_cache
+def human_bytes(n)
+  return "0 B" if n.nil? || n <= 0
+  units = %w[B KB MB GB TB]
+  i = (Math.log(n) / Math.log(1024)).floor
+  i = units.length - 1 if i >= units.length
+  format("%.2f %s", n.to_f / (1024 ** i), units[i])
+end
+
+def ttl_str(ttl)
+  case ttl
+  when -2 then "gone"
+  when -1 then "∞"
+  else
+    if ttl >= 86_400 then
+      "#{(ttl / 86_400.0).round(1)}d"
+    elsif ttl >= 3_600 then
+      "#{(ttl / 3_600.0).round(1)}h"
+    elsif ttl >= 60 then
+      "#{(ttl / 60.0).round(1)}m"
+    else
+      "#{ttl}s"
+    end
+  end
+end

data/lib/tasks/svelte_on_rails_tasks.rake

@@ -157,4 +157,4 @@ namespace :svelte_on_rails do
 
 end
 
-Rake::Task["assets:precompile"].enhance ["svelte_on_rails:precompile"]
+Rake::Task["assets:precompile"].enhance ["svelte_on_rails:precompile"]

data/templates/config_base/config/svelte_on_rails.yml

@@ -48,7 +48,6 @@ ssr_error_tag: true
 
 # redis_cache_store:
 #   url: 'redis://localhost:6379/2'
-#   expires_in: 90.minutes (=> default / fallback: 1 hour)
 #   namespace: 'my-app-svelte-on-rails'
 
 
@@ -56,6 +55,10 @@ use_caching: false
 # this is the default for the #svelte view-helper.
 # When set to true, the redis gem is required.
 
+cache_expires_in: 3.days
+# ttl for cache keys
+# default: 3.days
+
 debug: true
 # provides deeper logging with timestamps for performance improvements
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 22.2.0
+  version: 22.4.0
 platform: ruby
 authors:
 - Christian Sedlmair
@@ -84,6 +84,7 @@ files:
 - lib/svelte_on_rails/installer/npm_sandbox.rb
 - lib/svelte_on_rails/installer/svelte.rb
 - lib/svelte_on_rails/installer/utils.rb
+- lib/svelte_on_rails/lib/boot_context.rb
 - lib/svelte_on_rails/lib/cache_warmer.rb
 - lib/svelte_on_rails/lib/development_utils.rb
 - lib/svelte_on_rails/lib/fallback_renderer.rb
@@ -100,6 +101,7 @@ files:
 - lib/svelte_on_rails/ssr_client.rb
 - lib/svelte_on_rails/turbo_stream.rb
 - lib/svelte_on_rails/view_helpers.rb
+- lib/tasks/cache_tasks.rake
 - lib/tasks/svelte_on_rails_tasks.rake
 - templates/config_base/app/frontend/ssr/ssr.js
 - templates/config_base/config/svelte_on_rails.yml