svelte-on-rails 3.1.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8c8933b55b56b0a2adcc4c06542b0a9078b8e36408ae6afc9316289f2f2f924
-  data.tar.gz: 777395f46db7c8e2c88df9090b646088e39cb10cf9c2881ff7cd2f7a78dc8065
+  metadata.gz: 6ea6749866c7f8dc1f8a29c24c617d359e9b92c9c2d62557b32d475a4bbccdc8
+  data.tar.gz: 81b36d010aab7e8691a78f25a6b98acc69dab5eb1d238ab7c342afab81d170e5
 SHA512:
-  metadata.gz: 803bb9b519cc14baa104b41689c56dbe168fae17a1ec540a07dedcb8acc1200418f231446fe6ccd611f84d1c0607ffa335a312bed905512b5a95e12592bb6805
-  data.tar.gz: 51d06bdd84b8272d5af59bd9bbc4efd407d39a9b57c343a8d96a68e504770a135a951e18defa50b18e95443c319194c33e31287d922d63e7af4520f35345b85a
+  metadata.gz: 89a88fb47bb30c0b7119ea47b05734d5bdbed9dbe82413099316a29251ccdbabb55092760cf0473d6629326c89a4b50b585a2c023f62c48b771712a6c43395a4
+  data.tar.gz: ac545bd664f6ac91a9245c447954d01821d70af98443c5764efc4d5c84c063b83d592049a857ac85f65bd24c3f8f200964b20a7e784644e1d67346b3a5728968

data/README.md

@@ -28,6 +28,7 @@ On every app there are parts where you want it to shine. This is where Svelte co
   - One Logic in one file!
     - Render logic and script logic is in one file and, maybe, some css too.
   - Stimulus is great for rails views with some javascript, but, complex parts: You will love svelte.
+  - Improved Backend Response Time: Certain HTML components can be rendered directly by frontend JavaScript.
 - **Compared to React**
   - No more shadow dom and all those packages that are supposed to improve performance (e.g. useCallback...)
   - Slimmer packages
@@ -82,7 +83,7 @@ If you have issues, please open one, and contributors are welcome!
   - vite@6 (v7 not supported, see issues)
   - turbolinks and hotwired/turbo
 - vite_rails (the installer will install it by option --full or --vite)
-- svelte v5 (see: [how to install svelte on rails/vite](https://dev.to/chmich/setup-inertia-and-svelte-on-rails-7-3glk))
+- svelte@5, vite-plugin-svelte@5 (see: [how to install svelte on rails/vite](https://dev.to/chmich/setup-inertia-and-svelte-on-rails-7-3glk))
 - turbo (recommended / [how to install turbo on rails](https://github.com/hotwired/turbo-rails?tab=readme-ov-file#installation))
 - if you use special packages (like pug) that requires commonjs, you may need
 - npm on latest versions
@@ -299,6 +300,55 @@ the Svelte component is not visible for the first moment after rendering.
 Server-side rendering is unnecessary here. You can pass 'ssr: false' to the view helper.
 This relieves the server and reduces loading time.
 
+## Caching
+
+Caching only is relevant for `ssr`
+
+When using the `cached_svelte_component` helper you must have the `redis` gem installed.
+
+This caches on a key like `svelte-on-rails:development:SvelteOnRailsHelloWorld.svelte-1xq5tnu-User1:fscyhz-18bm76a` which includes:
+
+- gem name and environment
+- component filename
+- hash of the file-path
+- `cache_key` if given as argument to the view-helper
+  - can be a array of active-record objects or strings or a single element instead of a array
+- hash of the last modification timestamp of the component (only when `watch_changes` is set to true)
+- hash of the given properties
+
+**Caching strategy (!)** 
+
+Everytime the properties are changing, which are the last two elements of the hash key, which means all after the last colon,
+Previous hash keys are cleared by, for example: `svelte-on-rails:development:SvelteOnRailsHelloWorld.svelte-1xq5tnu-User1:*`
+
+That means: Please be aware to set your `cache_key` precisely for not invalidating cache keys that should not be cleared.
+
+On the other hand, please be aware that generating lots of record dependent cache keys will consume your memory, dependent on your 
+redis configuration.
+
+**Cache configuration**
+
+Like usually you can configure your cache store on your environment by something like:
+
+```ruby
+  config.cache_store = :redis_cache_store, { url: 'redis://localhost:6379/2',
+                                             expires_in: 90.minutes,
+                                             namespace: 'arcdigital_demo_cache' }
+```
+
+And you can override this by
+
+```yaml
+redis_cache_store:
+  expires_in: 2.hours
+```
+
+on the svelte-on-rails config file.
+
+**Tip**
+
+Pass `debug: true` to the helper and you will see on the logs how your configuration works.
+
 ## More rake tasks
 
 This tasks are more for testing/playground purposes

data/lib/generators/svelte_on_rails/install/install_generator.rb

@@ -43,7 +43,7 @@ module SvelteOnRails
         puts '-' * 80
         puts '• INSTALLING VITE-RAILS'
         vite_i = SvelteOnRails::Installer::Vite
-        vite_i.install_vite(major_version: 6)
+        vite_i.install_vite(version_specifier: '6')
       end
 
       def svelte_on_rails
@@ -98,7 +98,10 @@ module SvelteOnRails
 
         puts '-' * 80
         svelte_i = SvelteOnRails::Installer::Svelte
-        svelte_i.install_svelte
+        svelte_i.install_svelte(
+          svelte_version_specifier: '5',
+          vite_plugin_svelte_version_specifier: '5'
+        )
       end
 
       def hello_world

data/lib/svelte-on-rails.rb

@@ -2,6 +2,7 @@ require "svelte_on_rails/configuration"
 require "svelte_on_rails/view_helpers"
 require "svelte_on_rails/renderer/renderer"
 require "svelte_on_rails/lib/utils"
+require "svelte_on_rails/lib/view_helper_support"
 require "svelte_on_rails/railtie" if defined?(Rails)
 
 # installer

data/lib/svelte_on_rails/configuration.rb

@@ -10,23 +10,49 @@ module SvelteOnRails
     attr_accessor :configs
 
     def initialize
-      @configs = {
-        development: {
-          watch_changes: true,
-        },
-        test: {
-          watch_changes: true,
-        }
-      }
-      load_yaml_config if defined?(Rails)
+
+      @configs = redis_cache_store_configs
+
+      return unless defined?(Rails.root)
+
+      config_path = Rails.root.join("config", "svelte_on_rails.yml")
+      return unless File.exist?(config_path)
+
+      environments = Dir[Rails.root.join('config', 'environments', '*.rb')]
+                       .map { |file| File.basename(file, '.rb') }
+
+      configs_base = YAML.load_file(config_path)
+
+      @configs = @configs.deep_merge(configs_base.reject { |k, _| environments.include?(k) })
+
+      @configs = @configs.deep_merge(configs_base[Rails.env] || {})
+
+      @configs = @configs.symbolize_keys
+
+      if @configs[:redis_cache_store]
+        if @configs[:redis_cache_store]['expires_in'].is_a?(String)
+          @configs[:redis_cache_store]['expires_in'] = parse_duration(
+            @configs[:redis_cache_store]['expires_in']
+          )
+        end
+      end
+
+      if defined? Redis
+        @redis_instance = Redis.new(url: redis_cache_store[:url])
+      end
+
+    end
+
+    def redis_cache_store
+      (@configs[:redis_cache_store] || {}).with_indifferent_access
+    end
+
+    def redis_instance
+      @redis_instance
     end
 
     def watch_changes?
-      if @configs[Rails.env]
-        @configs[Rails.env]['watch_changes'] == true
-      else
-        false
-      end
+      @configs[:watch_changes] == true
     end
 
     def rails_root(root_url = nil)
@@ -34,25 +60,21 @@ module SvelteOnRails
     end
 
     def frontend_folder
-      Pathname.new(@configs['frontend_folder'].to_s)
+      Pathname.new(@configs[:frontend_folder].to_s)
     end
 
     def frontend_folder_full
-      rails_root.join(@configs['frontend_folder'].to_s)
+      rails_root.join(@configs[:frontend_folder].to_s)
     end
 
     def components_folder
-      Pathname.new(@configs['components_folder'].to_s)
+      Pathname.new(@configs[:components_folder].to_s)
     end
 
     def components_folder_full
       Pathname.new(frontend_folder_full).join(components_folder.to_s)
     end
 
-    def assets_folder
-      dist_folder.join('assets')
-    end
-
     def ssr_manifest
       file = rails_root.join('public', 'vite-ssr', 'manifest.json')
 
@@ -68,14 +90,8 @@ module SvelteOnRails
 
     end
 
-    # def manifest=(manifest_hash)
-    #   file = dist_folder.join('manifest.json')
-    #   @manifest = manifest_hash
-    #   File.write(file, JSON.pretty_generate(manifest_hash))
-    # end
-
     def ssr
-      rss = @configs['ssr']
+      rss = @configs[:ssr]
       if rss == false || rss == :auto
         rss
       else
@@ -84,7 +100,7 @@ module SvelteOnRails
     end
 
     def non_ssr_request_header
-      rss = @configs['non_ssr_request_header']
+      rss = @configs[:non_ssr_request_header]
       if rss.present?
         rss
       else
@@ -92,10 +108,6 @@ module SvelteOnRails
       end
     end
 
-    # def dist_folder(app_root = nil)
-    #   rails_root(app_root).join('public', 'svelteDist')
-    # end
-
     def client_dist_folder(app_root = nil)
       if Rails.env.development?
         rails_root(app_root).join('public', 'vite')
@@ -157,19 +169,25 @@ module SvelteOnRails
 
     private
 
-    def load_yaml_config
-      begin
-        config_path = Rails.root.join("config", "svelte_on_rails.yml")
-        return unless File.exist?(config_path)
-      rescue
-        return
+    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 }
+      else
+        {}
       end
+    end
 
-      config_data = YAML.load_file(config_path)
+    def parse_duration(string)
+      # Extract number and unit
+      match = string.match(/^(\d+)\.(\w+)$/)
+      raise ArgumentError, "Invalid duration format: #{string}" unless match
 
-      if config_data
-        @configs = @configs.merge(config_data)
-      end
+      number, unit = match[1].to_i, match[2]
+      # Ensure the unit is a valid ActiveSupport duration method
+      valid_units = %w[seconds minutes hours days weeks months years]
+      raise ArgumentError, "Invalid unit: #{unit} (valid: #{valid_units})" unless valid_units.include?(unit)
+      ActiveSupport::Duration.build(number.send(unit))
     end
+
   end
 end

data/lib/svelte_on_rails/installer/npm.rb

@@ -2,24 +2,21 @@ module SvelteOnRails
   module Installer
     module Npm
 
-      def self.install_or_update_package(package_name, minimal_version: nil, major_version: nil, update_to_latest: true, dev_dependency: false)
+      def self.install_or_update_package(package_name, version_specifier: 'latest', dev_dependency: false)
         pkg = inspect_package(package_name)
-        puts "#{package_name} already installed (#{pkg[:version].join('.')})" if pkg
+        puts "#{package_name} already installed (#{pkg[:version].join('.')}, specified: #{version_specifier})" if pkg
+        major_version = version_specifier.to_s.match(/^\d+(?=\.|$)/)
 
         to_do = if !pkg
                   true
                 elsif major_version
-                  r = pkg[:version].first != major_version
+                  r = pkg[:version].first != major_version.to_s.to_i
                   if r
                     puts "updating to major version #{major_version}"
                   else
                     puts "nothing to do (major version #{major_version} OK)"
                   end
                   r
-                elsif minimal_version
-                  r = pkg[:version].first < minimal_version.first || pkg[:version].second < minimal_version.second
-                  puts "updating to minimal version #{minimal_version}" if r
-                  r
                 else
                   puts 'nothing to do'
                   false
@@ -28,13 +25,7 @@ module SvelteOnRails
         save_dev = (dev_dependency ? ' --save-dev' : '')
         if to_do
 
-          cmd = if major_version
-                  "npm install #{package_name}@#{major_version}#{save_dev}"
-                elsif update_to_latest
-                  "npm install #{package_name}@latest#{save_dev}"
-                else
-                  raise "ERROR: not implemented"
-                end
+          cmd = "npm install #{package_name}#{'@' + version_specifier if version_specifier}#{save_dev}"
 
           stdout, stderr, status = Open3.capture3(cmd)
 
@@ -55,8 +46,7 @@ module SvelteOnRails
           puts notice
 
         else
-          min_str = minimal_version.present? ? ", required: >= #{minimal_version.join('.')}" : ''
-          puts "#{package_name} already installed (#{pkg[:version].join('.')}#{min_str}), skipping."
+          puts "#{package_name} already installed (#{pkg[:version].join('.')}, required: «#{version_specifier}»), skipping."
         end
       end
 
@@ -99,34 +89,6 @@ module SvelteOnRails
 
       end
 
-      # def self.check_version(current_version, minimal_version)
-      #   if !current_version
-      #     return false
-      #   elsif !minimal_version.present?
-      #     return true
-      #   else
-      #     compare_version_arrays(current_version, minimal_version)
-      #   end
-      # end
-
-      private
-
-      # def self.compare_version_arrays(current_version, minimal_version)
-      #   raise "ERROR: current_version must be an array" unless current_version.is_a?(Array)
-      #
-      #   current_version.each_with_index do |v, i|
-      #     raise "ERROR: current_version entries must be an integer" unless v.is_a?(Integer)
-      #
-      #     if minimal_version[i]
-      #       raise "ERROR: minimal_version entries must be an integer" unless minimal_version[i].is_a?(Integer)
-      #       if v < minimal_version[i]
-      #         return false
-      #       end
-      #     end
-      #   end
-      #   true
-      # end
-
     end
   end
 end

data/lib/svelte_on_rails/installer/svelte.rb

@@ -2,18 +2,18 @@ module SvelteOnRails
   module Installer
     module Svelte
 
-      def self.install_svelte(force: false)
+      def self.install_svelte(svelte_version_specifier: 'latest', vite_plugin_svelte_version_specifier: 'latest')
         puts '-' * 80
 
         # check npm package version
 
         npm_i = SvelteOnRails::Installer::Npm
-        npm_i.install_or_update_package('svelte', minimal_version: [5])
+        npm_i.install_or_update_package('svelte', version_specifier: svelte_version_specifier)
 
         # configure vite
 
         vite_i = SvelteOnRails::Installer::Vite
-        vite_i.configure_for_svelte
+        vite_i.configure_for_svelte(vite_plugin_svelte_version_specifier: vite_plugin_svelte_version_specifier)
 
       end
 

data/lib/svelte_on_rails/installer/vite.rb

@@ -4,7 +4,7 @@ module SvelteOnRails
 
     module Vite
 
-      def self.install_vite(major_version: nil, minimal_version: nil)
+      def self.install_vite(version_specifier: 'latest')
         iu = SvelteOnRails::Installer::Utils
 
         puts '-' * 80
@@ -44,18 +44,18 @@ module SvelteOnRails
         # check npm package version
 
         ni = SvelteOnRails::Installer::Npm
-        ni.install_or_update_package('vite', major_version: major_version, minimal_version: minimal_version)
+        ni.install_or_update_package('vite', version_specifier: version_specifier)
 
       end
 
-      def self.configure_for_svelte(force: false)
+      def self.configure_for_svelte(vite_plugin_svelte_version_specifier: nil)
 
         # add import statement
 
         js_i = SvelteOnRails::Installer::Javascript
         pkg = '@sveltejs/vite-plugin-svelte'
         npm_i = SvelteOnRails::Installer::Npm
-        npm_i.install_or_update_package(pkg)
+        npm_i.install_or_update_package(pkg, version_specifier: vite_plugin_svelte_version_specifier)
 
         # add plugin
 

data/lib/svelte_on_rails/lib/view_helper_support.rb

@@ -0,0 +1,193 @@
+# lib/svelte_on_rails/view_helper_support.rb
+module SvelteOnRails
+
+  module Lib
+    class ViewHelperSupport
+      attr_reader :filename, :helper_options, :html_options, :request, :conf
+
+      def initialize(file, props, request, caching = false)
+
+        @start_time = Time.now
+        @filename = (file.match(/\.svelte$/) ? file[0..-8] : file)
+        @conf = SvelteOnRails::Configuration.instance
+        @helper_options, @html_options, @props, @props_json = split_props(
+          props,
+          %i[class id style],
+          %i[ssr hydrate debug cache_key expires_in]
+        )
+        @request = request
+        @ssr = determine_ssr
+        validate_file if @conf.watch_changes?
+
+        # precompile
+
+        if !Dir.exist?(@conf.ssr_dist_folder) || @conf.watch_changes?
+          SvelteOnRails::Lib::Utils.watch_changes_and_precompile
+        end
+
+        # caching
+
+        if caching
+          raise '[svelte-on-rails] Caching required but Redis is not defined' unless defined?(Redis)
+        else
+          raise '[svelte-on-rails] :expires_in is not allowed for this helper' if @helper_options.key?(:expires_in)
+          raise '[svelte-on-rails] :cache_key is not allowed for this helper' if @helper_options.key?(:cache_key)
+          return
+        end
+
+        return unless ssr?
+
+        generate_cache_key
+
+      end
+
+      def debug?
+        @helper_options[:debug]
+      end
+
+      def redis_expiration_seconds
+        (conf.redis_cache_store[:expires_in] || 1.hour).to_i
+      end
+
+      def split_props(props, html_options, helper_options)
+        prp = {}
+        hlp_opts = {}
+        ht_opts = {
+          data: {
+            svelte_component: "/#{conf.components_folder + filename}",
+            controller: 'svelte-on-rails',
+          }
+        }
+
+        props.each do |k, v|
+          _k = k.to_sym
+          if helper_options.include?(_k)
+            hlp_opts[_k] = v
+          elsif html_options.include?(_k)
+            ht_opts[_k] = v
+          else
+            prp[_k] = v
+          end
+        end
+
+        ht_opts[:class] = "#{ht_opts[:class]} svelte-component".strip
+        prp_js = prp.to_json
+        ht_opts[:data][:props] = prp_js
+        ht_opts[:data][:svelte_status] = 'do-not-hydrate-me' if hlp_opts[:hydrate] == false
+
+        [hlp_opts, ht_opts, prp, prp_js]
+      end
+
+      def elapsed_milliseconds
+        ((Time.now - @start_time) * 1000).round(1)
+      end
+
+      def cache_key_primary
+        @cache_key_primary
+      end
+
+      def cache_key
+        @cache_key
+      end
+
+      def ssr?
+        @ssr
+      end
+
+      def file_not_found_message
+        ff = conf.frontend_folder
+        cf = conf.components_folder
+        "svelte-on-rails gem, view helper #svelte_component\n\nFile not found:\n" +
+          "#{conf.components_folder_full + "#{filename}.svelte"}\n\n" +
+          "Your configurations are:\n\nfrontend_folder: «#{ff}»\ncomponents_folder: «#{cf}»\n.. and the filename attribute for the view helper: «#{filename}»\n"
+      end
+
+      def file_case_sensitive_message
+        ff = conf.frontend_folder
+        cf = conf.components_folder
+        "svelte-on-rails gem, view helper #svelte_component\n\n" +
+          "File found but Upper and lower case letters are incorrect:\n" +
+          "(This check is only on development environments when watch_changes is true)\n\n" +
+          "#{conf.components_folder_full + "#{filename}.svelte"}\n\n" +
+          "Your configurations are:\nfrontend_folder: «#{ff}»\ncomponents_folder: «#{cf}»\n.. and the filename attribute for the view helper: «#{filename}»\n"
+      end
+
+      def log_rendering(message)
+
+        Rails.logger.info "  #{message} (#{elapsed_milliseconds}ms)"
+
+      end
+
+      def debug_log(message)
+        if debug?
+          Rails.logger.debug("  [svelte_component] #{message} (#{elapsed_milliseconds} ms)")
+        end
+      end
+
+      def render_ssr
+        renderer = SvelteOnRails::Renderer.new(filename)
+        renderer.render(@props)
+      end
+
+      private
+
+      def validate_file
+        file_path = conf.components_folder_full + "#{filename}.svelte"
+        unless File.exist?(file_path)
+          raise file_not_found_message
+        end
+        if conf.watch_changes? && !SvelteOnRails::Lib::Utils.file_exist_case_sensitive?(conf.components_folder_full, "#{filename}.svelte")
+          raise file_case_sensitive_message
+        end
+      end
+
+      def determine_ssr
+        _ssr = if @helper_options.key?(:ssr)
+                 if @conf.watch_changes?
+                   unless [true, false, :auto].include?(@helper_options[:ssr])
+                     raise "Only true, false, or :auto are allowed for the argument #ssr"
+                   end
+                 end
+                 @helper_options[:ssr]
+               else
+                 @conf.ssr
+               end
+        _ssr == :auto ? request.headers[conf.non_ssr_request_header].blank? : _ssr
+      end
+
+      private
+
+      def generate_cache_key
+
+        mtime_file = @conf.ssr_dist_folder.join('last_mtime')
+        mtime = File.read(mtime_file)
+
+        key2 = if @helper_options[:cache_key]
+                 k2 = (@helper_options[:cache_key])
+                 keys = k2.is_a?(Array) ? k2 : [k2]
+                 keys.map { |k| k.is_a?(ActiveRecord::Base) ? "#{k.class.name}#{k.id}" : k.to_s }.join('-')
+               end
+
+        filename_part = [
+          "#{filename.split('/').last}.svelte",
+          Zlib.crc32(filename).to_s(36),
+          key2
+        ].join('-')
+
+        @cache_key_primary = [
+          conf.redis_cache_store[:namespace] ? conf.redis_cache_store[:namespace] : "svelte-on-rails:#{Rails.env}",
+          filename_part,
+        ].join(':')
+
+        last_part = [
+          (@conf.watch_changes? ? Zlib.crc32(mtime).to_s(36) : nil),
+          Zlib.crc32(@props_json).to_s(36)
+        ].compact.join('-')
+
+        @cache_key = [@cache_key_primary, last_part].join(':')
+
+      end
+
+    end
+  end
+end

data/lib/svelte_on_rails/renderer/renderer.rb

@@ -11,10 +11,6 @@ module SvelteOnRails
         raise "Node.js not found at '#{config.node_bin_path}'. Please configure SvelteOnRails.node_bin (e.g., to ~/.nvm/versions/node/vX.Y.Z/bin/node) or ensure 'node' is in the PATH. If using NVM, run `nvm which default` to find the path."
       end
 
-      if !Dir.exist?(config.ssr_dist_folder) || config.watch_changes?
-        SvelteOnRails::Lib::Utils.watch_changes_and_precompile
-      end
-
       utils = SvelteOnRails::Lib::Utils
       @component_files = utils.component_files(component_name, base_path: base_path)
 

data/lib/svelte_on_rails/view_helpers.rb

@@ -1,105 +1,84 @@
+# lib/svelte_on_rails/view_helpers.rb
 module SvelteOnRails
   module ViewHelpers
 
     def svelte_component(filename, props = {})
 
-      # check filename
-      conf = SvelteOnRails::Configuration.instance
-      cff = conf.components_folder_full
-      file_path = cff + "#{filename}.svelte"
-      if !File.exist?(file_path)
-        raise file_not_found_messsage(filename)
-      elsif conf.watch_changes? && !SvelteOnRails::Lib::Utils.file_exist_case_sensitive?(cff, filename + '.svelte')
-        # on development environments we check case sensitivity too
-        msg = "File found but Upper and lower case letters are incorrect\n" +
-          "(This check is only on development environments when watch_changes is true):\n."
-        raise file_case_sensitive_messsage(filename)
-      end
+      support = SvelteOnRails::Lib::ViewHelperSupport.new(filename, props, request, false)
 
-      # check what to do
+      support.debug_log("Rendering component: #{filename}")
+      log_message = '?'
 
-      rss = if props.key?(:ssr)
-              props.delete(:ssr)
-            else
-              conf.ssr
-            end
-      unless [true, false, :auto].include?(rss)
-        raise "Only true, false or auto are allowed for the argument #ssr"
+      log_message = "Rendered #{support.filename}.svelte #{'as empty element that will be mounted on the client side' unless support.ssr?}"
+      res = render_component(support)
+
+      support.log_rendering(log_message)
+
+      res
+
+    end
+
+    def cached_svelte_component(filename, props = {})
+
+      support = SvelteOnRails::Lib::ViewHelperSupport.new(filename, props, request, true)
+
+      support.debug_log("Rendering component: #{filename}")
+      log_message = '?'
+      redis = support.conf.redis_instance
+
+      support.debug_log("Redis configuration: #{support.conf.redis_cache_store}")
+
+      # TTL
+      if support.debug?
+        ttl = redis.ttl(support.cache_key)
+        support.debug_log("Cache key: #{support.cache_key} (ttl was: #{ttl} seconds, now set to: #{support.redis_expiration_seconds} seconds)")
       end
+      redis.expire(support.cache_key, support.redis_expiration_seconds)
+
+      cached_content = redis.get(support.cache_key)
 
-      ssr = if [:auto, 'auto'].include?(rss)
-              request.headers[conf.non_ssr_request_header].blank?
+      res = if cached_content
+              log_message = "Returned #{support.filename}.svelte from cache"
+              cached_content.html_safe
             else
-              rss
+              log_message = "Rendered #{support.filename}.svelte and stored to cache"
+              support.debug_log("cache recalculating for key: #{support.cache_key}")
+              r = render_component(support)
+              support.debug_log("cache recalculated")
+
+              redis.scan_each(match: "#{support.cache_key_primary}:*") do |key|
+                redis.del(key)
+                support.debug_log("deleted cache: #{key}")
+              end
+
+              redis.set(support.cache_key, r)
+              r
             end
 
-      hydrate = if props.key?(:hydrate)
-                  props[:hydrate]
-                else
-                  true
-                end
-
-      # separate hashes
-
-      props.delete(:hydrate)
-      props.delete(:ssr)
-      options = props.slice(:class, :id, :style)
-      props.delete(:class)
-      props.delete(:id)
-      props.delete(:style)
+      support.log_rendering(log_message)
 
-      # set up html
+      res
 
-      options[:class] = options[:class].to_s + ' svelte-component'
-      options[:data] ||= {}
-      options[:data][:svelte_status] = 'do-not-hydrate-me' unless hydrate
-      options[:data][:props] = props.to_json
-      options[:data][:svelte_component] = "/#{conf.components_folder + filename}"
-      options[:data][:controller] = 'svelte-on-rails'
+    end
 
-      if ssr
+    private
 
-        # render server side
+    def render_component(support)
 
-        start_time = Time.now
-        rend = SvelteOnRails::Renderer.new(filename)
-        res = rend.render(props)
-        time = Time.now - start_time
-        Rails.logger.info "  Rendered #{filename}.svelte server-side: #{time.round(3)}ms"
+      if support.ssr?
 
-        content_tag(:div, options) do
-          r = content_tag(:style, res['css'], type: 'text/css')
-          r << res['html'].html_safe
+        ssr_result = support.render_ssr
+        content_tag(:div, support.html_options) do
+          concat(content_tag(:style, ssr_result['css'], type: 'text/css'))
+          concat(ssr_result['html'].html_safe)
         end
 
       else
 
-        # render empty element
-        Rails.logger.info "  Rendered #{filename}.svelte as empty element that will be mounted on the client side"
-        content_tag(:div, options) {}
+        content_tag(:div, support.html_options) {}
 
       end
     end
 
-    def file_not_found_messsage(filename)
-      conf = SvelteOnRails::Configuration.instance
-      ff = conf.frontend_folder
-      cf = conf.components_folder
-      "svelte-on-rails gem, view helper #svelte_component\n\nFile not found:\n" +
-        "#{conf.components_folder_full + "#{filename}.svelte"}\n\n" +
-        "Your configurations are:\n\nfrontend_folder: «#{ff}»\ncomponents_folder: «#{cf}»\n.. and the filename attribute for the view helper: «#{filename}»\n"
-    end
-
-    def file_case_sensitive_messsage(filename)
-      conf = SvelteOnRails::Configuration.instance
-      ff = conf.frontend_folder
-      cf = conf.components_folder
-      "svelte-on-rails gem, view helper #svelte_component\n\n" +
-        "File found but Upper and lower case letters are incorrect:\n" +
-        "(This check is only on development environments when watch_changes is true)\n\n" +
-        "#{conf.components_folder_full + "#{filename}.svelte"}\n\n" +
-        "Your configurations are:\nfrontend_folder: «#{ff}»\ncomponents_folder: «#{cf}»\n.. and the filename attribute for the view helper: «#{filename}»\n"
-    end
-
   end
 end

data/templates/config_base/config/svelte_on_rails.yml

@@ -16,6 +16,11 @@ non_ssr_request_header: 'X-Turbo-Request-ID'
 # when this header contains any value (not blank), we are skipping server-side rendering
 # when this header is empty we assume initial request and doing server-side rendering
 
+# redis_cache_store:
+#   url: 'redis://localhost:6379/2'
+#   expires_in: 90.minutes (=> default / fallback: 1 hour)
+#   namespace: 'my-app-svelte-on-rails'
+
 development:
   watch_changes: true
   # Check on every request if any file within the svelte components folder have changed, for recompiling
@@ -24,5 +29,6 @@ development:
 
 test:
   watch_changes: true
+  cache_expiration_hours: 15
 
 production:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 4.0.0
 platform: ruby
 authors:
 - Christian Sedlmair
@@ -42,6 +42,7 @@ files:
 - lib/svelte_on_rails/installer/vite.rb
 - lib/svelte_on_rails/lib/development_utils.rb
 - lib/svelte_on_rails/lib/utils.rb
+- lib/svelte_on_rails/lib/view_helper_support.rb
 - lib/svelte_on_rails/railtie.rb
 - lib/svelte_on_rails/renderer/render.js
 - lib/svelte_on_rails/renderer/renderer.rb