svelte-on-rails 20.0.18 → 21.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7711f39780f053fa47efe51b4f6c2de5b31afd3ff0feb28728003caa96618a40
-  data.tar.gz: 85d5e6687e93b28d79746e1ea535f193d1f8e76b368f40a4a925642fbc67ae52
+  metadata.gz: d147f7ea42b28a7d979d93b2ba336fe2076763d1b05d248ff6b2d17dc293ef10
+  data.tar.gz: b33ff7321a8db1c2b58350d8a433d75329727f625030e96a53e70ecaf093b572
 SHA512:
-  metadata.gz: eb80a3bff65909ddaa0d1a27f81b34f5d31e6f101ba4c138b8def261774c9bffecbc748933323f320c49bb47f5efc8bd6395c0893f941d4fd4f311a309533d54
-  data.tar.gz: 6054c173995e79a91fb770d5fc924a4795e6c7fdd6c934961872d4a7dedeb525de3b15b998f08d3b5a67ff3524d43472389934c57f7791dca6fcc03a57c7175a
+  metadata.gz: 063f55d363284af5924f1a07966b1da39f1b17c123ad93060b29fa6832941d77337de852d9a9f9b38fe9cf4489a3d59852bc50b1a067176ddd1ca67db5a11b15
+  data.tar.gz: 06fc37fa2b5fa1cebdfb8fc4758b9fa27e87a0d7b09484df648dee441ffc2df5a79f48da79d6549adf06c139289b233a0628f5d4c07d353eb6df54f753d4c403

data/lib/svelte_on_rails/configuration.rb

@@ -16,6 +16,7 @@ module SvelteOnRails
 
       @boot_key = SecureRandom.hex(3) # currently not used, more for debugging purposes
       @configs = redis_cache_store_configs
+      set_config_defaults
 
       @component_paths_cache = {}
       @request_metrics = {}
@@ -36,9 +37,11 @@ module SvelteOnRails
       merged_configs = configs_base.deep_merge(env_configs || {})
 
       # cleanup
-      @configs = merged_configs.reject { |k, _| environments.include?(k.to_s) }
+      polished_configs = merged_configs.reject { |k, _| environments.include?(k.to_s) }
+      @configs = @configs.merge(polished_configs)
+
+      # DEFAULTS
 
-      # caching defaults
       if @configs[:redis_cache_store]
         store = @configs[:redis_cache_store]
         if store['expires_in'].is_a?(String)
@@ -54,10 +57,18 @@ module SvelteOnRails
         @redis_instance = Redis.new(url: redis_cache_store[:url])
       end
 
-      validate_configs
+      validate_serialized_configs
+      custom_config_validations
       validate_npm_packages
     end
 
+    def set_config_defaults
+      @configs[:ssr_server] = true
+      @configs[:ssr_server_workers] = 1
+      @configs[:ssr_fallback_renderer] = false
+      @configs[:ssr_error_tag] = true
+    end
+
     def redis_cache_store
       (@configs[:redis_cache_store] || {}).transform_keys(&:to_sym)
     end
@@ -139,7 +150,9 @@ module SvelteOnRails
     end
 
     def ssr_server_bin_path
-      Rails.root.join(Pathname('node_modules/@csedl/svelte-on-rails/bin/svelte-ssr-server.js'))
+      wk = @configs[:ssr_server_workers]
+      str = wk > 1 ? 'cluster' : 'server'
+      Rails.root.join(Pathname("node_modules/@csedl/svelte-on-rails/bin/svelte-ssr-#{str}.js"))
     end
 
     def initialize_request_metrics(request_uuid)
@@ -184,7 +197,7 @@ module SvelteOnRails
       ActiveSupport::Duration.build(number.send(unit))
     end
 
-    def validate_configs
+    def validate_serialized_configs
 
       # custom validations
 
@@ -196,9 +209,13 @@ module SvelteOnRails
 
       keys = {
         vite_source_dir: { required: :string },
-        use_ssr_server: { required: :boolean },
         use_caching: { required: :boolean },
 
+        ssr_server: { optional: :boolean },
+        ssr_server_workers: { optional: :integer },
+        ssr_fallback_renderer: { optional: :boolean },
+        ssr_error_tag: { optional: :boolean },
+
         cache_expiration_hours: { optional: :integer },
         components_subdir: { optional: :string },
         default_components_root: { required: :string },
@@ -262,6 +279,15 @@ module SvelteOnRails
 
     end
 
+    def custom_config_validations
+      if !@configs[:ssr_server] && !@configs[:ssr_fallback_renderer]
+        raise "[SOR] Configuration error: Either :ssr_server or :ssr_fallback_renderer must be set to true"
+      end
+      if @configs[:ssr_server_workers] < 1
+        raise "[SOR] Configuration error: :ssr_server_workers must be greater than 0"
+      end
+    end
+
     def validate_npm_packages
       pkg = JSON.parse(File.read(Rails.root.join('package.json')))
       deps = (pkg['dependencies'] || {}).merge(pkg['devDependencies'] || {})
@@ -280,12 +306,20 @@ module SvelteOnRails
           raise "[Svelte-on-Rails] NPM-Package @csedl/svelte-on-rails: Could not detect version from: «#{sor}»"
         end
 
-        if Gem::Version.new(version) < Gem::Version.new('14.0.0')
-          raise "[Svelte-on-Rails] NPM-Package @csedl/svelte-on-rails: At least version 14.0.0 is required, but found: «#{sor}»"
+        # npm package version
+
+        if Gem::Version.new(version) < Gem::Version.new('15.0.0')
+          raise "[Svelte-on-Rails] NPM-Package @csedl/svelte-on-rails: At least version 15.0.0 is required, but found: «#{sor}»"
         end
 
-        unless node_version_test.to_s.match(/v\d+\.\d+\.\d+/)
-          raise "[Svelte-on-Rails] Node Version could not be detected.\nPlease check your Node.js installation:\n#{@node_bin_path_log.join("\n")}"
+        # check version
+        if @configs[:ssr]
+          unless node_version_test.to_s.match(/v\d+\.\d+\.\d+/)
+            raise "[Svelte-on-Rails] Node Version could not be detected.\nPlease check your Node.js installation:\n#{@node_bin_path_log.join("\n")}"
+          end
+          if Gem::Version.new(node_version_test.to_s.delete_prefix('v')) < Gem::Version.new('22.0.0')
+            raise "[Svelte-on-Rails] Node Version (#{}) is too old, at least version 22.0.0 is required"
+          end
         end
       end
 

data/lib/svelte_on_rails/lib/utils.rb

@@ -153,16 +153,17 @@ module SvelteOnRails
         trace[0..last_match_index]
       end
 
+      # Log for debugging purposes
       def self.secure_debug_log(line)
-        base = Rails.root.join('tmp')
+        # base = Rails.root.join('tmp')
 
-        FileUtils.mkdir_p(base) unless File.directory?(base)
-        path = File.join(base.to_s, 'sor.log')
+        # FileUtils.mkdir_p(base) unless File.directory?(base)
+        # path = File.join(base.to_s, 'svelte-on-rails.log')
 
-        File.open(path, 'a') do |f|
-          f.sync = true
-          f.puts("[#{Time.now.utc.iso8601(3)}] [pid=#{Process.pid}] #{line}")
-        end
+        # File.open(path, 'a') do |f|
+        #   f.sync = true
+        #   f.puts("[#{Time.now.utc.iso8601(3)}] [pid=#{Process.pid}] #{line}")
+        # end
       rescue => e
         # Last resort: write the failure itself to stderr; never raise.
         warn "[SOR] sor_debug_log failed: #{e.class}: #{e.message}"

data/lib/svelte_on_rails/lib/view_helper_support.rb

@@ -164,16 +164,8 @@ module SvelteOnRails
           caller_locations.find { |loc| loc.to_s.include?(v_path) }.to_s.match(/^[\s\S]+(:[0-9]+(?=:in))/).to_s
         end
 
-        r = if SvelteOnRails::SsrServer.instance.alive?
-              SvelteOnRails::SsrServer.instance.render(
-                component_paths,
-                cached_props,
-                debug?,
-                caller_loc
-              )
-            else
-              SvelteOnRails::Lib::FallbackRenderer.render(component_paths, cached_props, debug?)
-            end
+        r = render_with_ssr_server(caller_loc) || render_with_fallback
+
         if r[:success]
           set_request_metrics(:rendered)
         else
@@ -237,6 +229,24 @@ module SvelteOnRails
 
       private
 
+      def render_with_ssr_server(caller_loc)
+        return {} unless @conf.configs[:ssr_server]
+
+        result = SvelteOnRails::SsrServer.instance.render(
+          component_paths,
+          cached_props,
+          debug?,
+          caller_loc
+        )
+        result[:success] ? result : render_with_fallback
+      end
+
+      def render_with_fallback
+        return {} unless @conf.configs[:ssr_fallback_renderer]
+
+        SvelteOnRails::Lib::FallbackRenderer.render(component_paths, cached_props, debug?)
+      end
+
       def run_vite_build
         r = @conf.vite_build
 
@@ -298,6 +308,11 @@ module SvelteOnRails
       end
 
       def resolve_ssr?(request)
+
+        # Setting SSR to false at the global level will disable SSR.
+        # Reason: In emergency cases, the developer may want to disable SSR.
+        return false if @conf.configs[:ssr] == false
+
         _ssr = if !@options[:ssr].nil?
                  @options[:ssr]
                elsif !@conf.configs[:ssr].nil?

data/lib/svelte_on_rails/railtie.rb

@@ -18,9 +18,9 @@ module SvelteOnRails
       app.config.after_initialize do
 
         if defined?(Rake) && Rake.respond_to?(:application) && Rake.application.top_level_tasks.any?
-          puts "[Skipping svelte-on-rails because of top level task: #{Rake.application.top_level_tasks.join(', ')}]"
+          puts "[Skipping svelte-on-rails SSR-Server because of top level task: #{Rake.application.top_level_tasks.join(', ')}]"
           $stdout.flush
-        else
+        elsif SvelteOnRails::Configuration.instance.configs[:ssr]
           SvelteOnRails::Lib::Utils.secure_debug_log("Initializing SSR client")
           SvelteOnRails::SsrServer.instance
           SvelteOnRails::Lib::Utils.secure_debug_log("Initializing SSR client finished")

data/lib/svelte_on_rails/ssr_server.rb

@@ -28,13 +28,12 @@ module SvelteOnRails
       @logfile_path = Rails.root.join("log/svelte-ssr-server-#{Rails.env}.log")
       @logfile_max_lines = build_logfile_max_lines
       @socket_path = @helpers.socket_path
-      @use_ssr_server = SvelteOnRails::Configuration.instance.configs[:use_ssr_server]
-      @node_bin = SvelteOnRails::Configuration.instance.node_bin_path
-      @ssr_server_bin_path = SvelteOnRails::Configuration.instance.ssr_server_bin_path
+      @ssr_server = SvelteOnRails::Configuration.instance.configs[:ssr_server]
+      @ssr_server_bin_path = @helpers.ssr_server_bin_path
 
       File.delete(restart_marker_file) if File.exist?(restart_marker_file)
 
-      if @use_ssr_server
+      if @ssr_server
         # if !defined?(Rails::Server)
         #   SvelteOnRails::Lib::Utils.secure_debug_log("Rails Server is not yet defined, SSR Server cannot be started because of initializing too early")
         # else
@@ -48,8 +47,8 @@ module SvelteOnRails
           File.delete(restart_marker_file) if File.exist?(restart_marker_file)
         end
       else
-        SvelteOnRails::Lib::Utils.secure_debug_log("SSR Server NOT used => @use_ssr_server #{@use_ssr_server}")
-        SvelteOnRails::Lib::Utils.secure_debug_log("SSR Server NOT used => @use_ssr_server #{defined?(Rails::Server)}")
+        SvelteOnRails::Lib::Utils.secure_debug_log("SSR Server NOT used => @ssr_server #{@ssr_server}")
+        SvelteOnRails::Lib::Utils.secure_debug_log("SSR Server NOT used => @ssr_server #{defined?(Rails::Server)}")
       end
 
     end
@@ -149,7 +148,6 @@ module SvelteOnRails
     end
 
     def ping?
-      @alive = false
       shorten_logfile
       unless File.exist?(socket_path)
         return false
@@ -169,7 +167,7 @@ module SvelteOnRails
         unless r['version'].split('.').first.to_i >= 14
           puts "[SOR] WARNING: Required SSR Server version is at least 14.x, you have installed @csedl/svelte-on-rails: #{r['version']}"
         end
-        @alive = r['status'] == 'alive'
+        r['status'] == 'alive'
       end
     end
 
@@ -182,17 +180,11 @@ module SvelteOnRails
       File.write(@helpers.ssr_server_ppid_file, Process.ppid.to_s)
 
       start = Time.now
-      cmd = [
-        "SVELTE_SSR_SERVER_STARTED_BY=#{started_by}",
-        @node_bin,
-        @ssr_server_bin_path,
-        @socket_path
-      ].join(' ')
 
       @node_server_output = {}
       Thread.new do
         stdout, stderr, status = Open3.capture3(
-          cmd,
+          @helpers.start_node_server_command(started_by),
           chdir: Rails.root
         )
         @node_server_output = {
@@ -201,57 +193,30 @@ module SvelteOnRails
           status: status
         }
       end
-      start_server_log(start, "Node Version: #{Configuration.instance.node_version_test}, package version: #{Configuration.instance.npm_package_version_test}")
-      start_server_log(start, "Start running Svelte-SSR-Server... (#{started_by})")
+      @helpers.start_server_log(start, "Node Version: #{Configuration.instance.node_version_test}, package version: #{Configuration.instance.npm_package_version_test}")
+      @helpers.start_server_log(start, "Start running Svelte-SSR-Server... (#{started_by})")
 
       until node_server_pid do
         sleep 0.12
-        start_server_log(start, "Waiting for node server process-id")
+        @helpers.start_server_log(start, "Waiting for node server process-id")
         start_server_timeout!(start)
       end
 
       until File.exist?(socket_path) do
         sleep 0.1
-        start_server_log(start, "Waiting for socket to be created")
+        @helpers.start_server_log(start, "Waiting for socket to be created")
         start_server_timeout!(start)
       end
-      start_server_log(start, "Socket created: #{socket_path}")
+      @helpers.start_server_log(start, "Socket created: #{socket_path}")
 
       until ping? do
-        start_server_log(start, "Waiting for successful server-response")
+        @helpers.start_server_log(start, "Waiting for successful server-response")
         start_server_timeout!(start)
         sleep 0.1
       end
-      start_server_log(start, "Server responded successfully")
-
-      kill_leftover_processes
-    end
-
-    def kill_leftover_processes
-      stdout, stderr, status = Open3.capture3(
-        "ps aux | grep svelte"
-      )
-
-      leftover = stdout.split("\n").map do |line|
-        if line.match?(/\/#{@socket_namespace}-[0-9]+.sock$/)
-          unless line.match?(/\/#{@socket_namespace}-#{Process.ppid}.sock$/)
-            line.match(/[0-9]+/).to_s.to_i
-          end
-        end
-      end.compact
-
-      stdout, stderr, status = Open3.capture3(
-        "kill #{leftover.join(' ')}"
-      )
-
-      start_server_log(nil, "Killed #{leftover.length} leftover processes") if leftover.length >= 1
-    end
-
-    def kill_my_server
-      Process.kill("SIGINT", (node_server_pid || 0)) if node_server_pid
-      File.delete(@helpers.ssr_server_ppid_file)
-    rescue
+      @helpers.start_server_log(start, "Server responded successfully")
 
+      @helpers.cleanup_leftover_processes
     end
 
     def restart_my_server(tag = nil)
@@ -274,10 +239,6 @@ module SvelteOnRails
       end
     end
 
-    def alive?
-      @alive
-    end
-
     def node_server_pid
       stdout, stderr, status = Open3.capture3(
         "ps aux | grep svelte"
@@ -320,21 +281,6 @@ module SvelteOnRails
       end
     end
 
-    def start_server_log(start_time, msg)
-      line =
-        if start_time
-          ms = ((Time.now - start_time) * 1000).round(1)
-          "[SOR] #{msg} (#{ms}ms)"
-        else
-          "[SOR] #{msg}"
-        end
-
-      puts line
-      $stdout.flush
-
-      SvelteOnRails::Lib::Utils.secure_debug_log(line)
-    end
-
     def stop_server_timeout!(start_time, timeout: 2000)
       ms = ((Time.now - start_time) * 1000).round(1)
       if ms > timeout
@@ -385,7 +331,8 @@ module SvelteOnRails
     # For that reason they are within a separate class
 
     attr_reader :socket_namespace,
-                :socket_path
+                :socket_path,
+                :ssr_server_bin_path
 
     def initialize
 
@@ -395,6 +342,8 @@ module SvelteOnRails
         Rails.env,
       ].join("-")
 
+      @ssr_server_bin_path = SvelteOnRails::Configuration.instance.ssr_server_bin_path
+
     end
 
     def ssr_server_ppid_file
@@ -417,6 +366,97 @@ module SvelteOnRails
       fallback
     end
 
+    def start_node_server_command(started_by, ppid: Process.ppid)
+      workers = SvelteOnRails::Configuration.instance.configs[:ssr_server_workers]
+      [
+        (started_by ? "SVELTE_SSR_SERVER_STARTED_BY=#{started_by}" : nil),
+        SvelteOnRails::Configuration.instance.node_bin_path,
+        @ssr_server_bin_path,
+        socket_path(ppid: ppid),
+        (workers > 1 ? "--workers=#{workers}" : nil)
+      ].compact.join(' ')
+    end
+
+    SsrProcess = Struct.new(:pid, :ppid, :socket_path, keyword_init: true)
+
+    def own_processes(current_ppid: Process.ppid)
+      scan_processes.select { |p| p.ppid == current_ppid }
+    end
+
+    def leftover_processes(current_ppid: Process.ppid)
+      scan_processes.reject { |p| p.ppid == current_ppid }
+    end
+
+    def leftover_sockets(current_ppid: Process.ppid)
+      scan_sockets.reject { |s| s[:ppid] == current_ppid }
+    end
+
+    def cleanup_leftover_processes(current_ppid: Process.ppid)
+      terminate_processes(leftover_processes(current_ppid: current_ppid), label: "leftover")
+      delete_sockets(leftover_sockets(current_ppid: current_ppid).map { |s| s[:path] }, label: "leftover")
+    end
+
+    def shutdown(current_ppid: Process.ppid)
+      terminate_processes(own_processes(current_ppid: current_ppid), label: "own")
+    ensure
+      File.delete(ssr_server_ppid_file) if File.exist?(ssr_server_ppid_file)
+    end
+
+    def start_server_log(start_time, msg)
+      line = start_time ? "[SOR] #{msg} (#{((Time.now - start_time) * 1000).round(1)}ms)" : "[SOR] #{msg}"
+      puts line
+      $stdout.flush
+      SvelteOnRails::Lib::Utils.secure_debug_log(line)
+    end
+
+    private
+
+    # Cluster mode: a primary + N workers share one socket path.
+    # SIGINT the primary first (lowest pid per socket group); survivors get SIGINT too.
+    def terminate_processes(processes, label:)
+      return if processes.empty?
+
+      processes.group_by(&:socket_path).values.flat_map { |g| g.sort_by(&:pid) }.each do |p|
+        Process.kill("SIGINT", p.pid) rescue Errno::ESRCH || Errno::EPERM
+      end
+
+      start_server_log(nil, "Killed #{processes.length} #{label} process#{'es' if processes.length != 1}")
+    end
+
+    def delete_sockets(socket_paths, label:)
+      return if socket_paths.empty?
+
+      socket_paths.uniq.each do |path|
+        File.delete(path) if File.exist?(path)
+      rescue Errno::ENOENT
+        # raced with primary's own cleanup — fine
+      end
+
+      start_server_log(nil, "Deleted #{socket_paths.size} #{label} socket#{'s' if socket_paths.size != 1}")
+    end
+
+    # All running SSR processes matching our namespace (any ppid).
+    def scan_processes
+      stdout, = Open3.capture3("ps aux | grep svelte | grep -v grep")
+      regex = %r{(/\S*#{Regexp.escape(@socket_namespace)}-(\d+)\.sock)\b}
+
+      stdout.each_line.filter_map do |line|
+        m = line.match(regex) or next
+        pid = Integer(line.split(/\s+/, 12)[1], exception: false) or next
+        SsrProcess.new(pid: pid, ppid: m[2].to_i, socket_path: m[1])
+      end
+    end
+
+    # All socket files on disk matching our namespace (any ppid).
+    # Looks in both the app's tmp/sockets dir and the macOS/BSD fallback dir.
+    def scan_sockets
+      dirs = [Rails.root.join("tmp/sockets").to_s, "/tmp/svelte"]
+      regex = /#{Regexp.escape(@socket_namespace)}-(\d+)\.sock\z/
+
+      dirs.flat_map { |d| Dir.glob(File.join(d, "#{@socket_namespace}-*.sock")) }
+          .filter_map { |path| (m = path.match(regex)) && { path: path, ppid: m[1].to_i } }
+    end
+
   end
 
   class SsrError < StandardError; end

data/lib/svelte_on_rails/view_helpers.rb

@@ -48,8 +48,10 @@ module SvelteOnRails
                   concat(rnd[:head].html_safe)
                   concat(rnd[:html].html_safe)
                   support.log_completed("returned from cache, with uncached props#{', (Fallback!)' if rnd[:fallback]}")
-                else
+                elsif config.configs[:ssr_error_tag]
                   sor_error_tag(support, wrapper_html, component_props, 'server-side-svelte-render-error', 'SVELTE RENDER FAILED')
+                else
+                  render_empty_tag(support, wrapper_html, component_props)
                 end
               end
             end
@@ -74,7 +76,11 @@ module SvelteOnRails
                 r
               else
                 log = "ERROR"
-                sor_error_tag(support, wrapper_html, component_props, 'server-side-svelte-render-error', 'SVELTE RENDER FAILED')
+                if config.configs[:ssr_error_tag]
+                  sor_error_tag(support, wrapper_html, component_props, 'server-side-svelte-render-error', 'SVELTE RENDER FAILED')
+                else
+                  render_empty_tag(support, wrapper_html, component_props)
+                end
               end
             end
             support.log_completed(log)
@@ -92,8 +98,10 @@ module SvelteOnRails
                   concat(rnd[:head].html_safe)
                   concat(rnd[:html].html_safe)
                 end
-              else
+              elsif config.configs[:ssr_error_tag]
                 sor_error_tag(support, wrapper_html, component_props, 'server-side-svelte-render-error', 'SVELTE RENDER FAILED')
+              else
+                render_empty_tag(support, wrapper_html, component_props)
               end
 
           support.log_completed("Rendered#{rnd[:fallback] ? ' (Fallback!)' : ''} #{'as empty element that will be mounted on the client side' unless support.ssr?}")

data/lib/tasks/svelte_on_rails_tasks.rake

@@ -7,18 +7,31 @@ namespace :svelte_on_rails do
   desc "check ssr requirements and status"
   task :check do
 
+    line_width = 100
     configs = SvelteOnRails::Configuration.instance
     ppid_file = Rails.root.join("tmp", "pids", 'svelte_on_rails.ppid')
     ppid = (ppid_file.exist? ? File.read(ppid_file).chomp : nil)
     server_helpers = SvelteOnRails::SsrServerHelpers.new
     socket_path = server_helpers.socket_path(ppid: ppid)
+    curl_installed = system('which curl > /dev/null 2>&1')
+    if curl_installed
+      curl_cmd = "curl --unix-socket #{socket_path} http://localhost"
+      stdout, stderr, status = Open3.capture3(curl_cmd + '/health')
+      srv_details = (JSON.parse(stdout) rescue {})
+    end
 
-    rails_env_warning(socket_path)
+    env_check = rails_env_check(socket_path)
 
-    puts '=' * 80
-    puts "Svelte on Rails SSR Server"
-    puts "Rails env: #{Rails.env.upcase}"
-    puts '=' * 80
+    puts
+    puts '=' * line_width
+    puts "Svelte on Rails SSR Server Status:"
+    puts "  Rails env: #{Rails.env.upcase}"
+    if srv_details['uptime']
+      puts "  Uptime: #{srv_details['uptime'].round(0)}sec"
+    else
+      puts "  Status: not running"
+    end
+    puts '=' * line_width
     puts
     puts 'Node'
     puts label('Node bin') + configs.node_bin_path.to_s
@@ -29,41 +42,96 @@ namespace :svelte_on_rails do
     puts 'Rails instance'
     if !server_helpers.ssr_server_ppid_file.exist?
       puts label('Process.ppid') + "#{server_helpers.ssr_server_ppid_file} not found, rails seems not to run or the SsrServer is not initialized yet."
-    else
+    elsif env_check == :clearly_correct
       puts label('Process.ppid') + ppid.to_s
       puts label('Socket') + socket_path.to_s
-      puts 'Command for check the server instance:'
-      puts "  • curl --unix-socket #{socket_path} http://localhost"
+    else
+      puts 'Rails env could not be determinated, compared to the socket path, so, no socket path could be determined.'
     end
     puts
-    puts '=' * 80
+    puts '=' * line_width
+    puts
     puts 'MORE DETAILS:'
     puts
     puts 'How was the node bin path determined:'
     configs.instance_variable_get(:@node_bin_path_log).each do |line|
       puts "  • #{line}"
+      puts "  • kill #{line}"
     end
     puts
+    puts 'Commands:'
+    puts "  • node path/to/svelte-ssr-server.js path/to/socket.sock:"
+    puts "    • #{server_helpers.start_node_server_command(nil)}"
+    if srv_details['pid']
+      puts "  • #{curl_cmd}"
+      puts "  • kill #{srv_details['pid']}" if srv_details['pid']
+    end
+    puts
+    if env_check == :clearly_correct
+      puts '=' * line_width
+      puts
+      puts 'NODE INSTANCE INFO:'
+      puts '  (output of the above mentioned curl command)'
+      puts
+      puts '-' * line_width
+      if curl_installed
+        stdout, stderr, status = Open3.capture3(curl_cmd)
+        if status.success?
+          puts stdout
+        else
+          puts "curl exited with status #{status.exitstatus}"
+          puts stderr unless stderr.to_s.strip.empty?
+        end
+      else
+        puts "curl is not installed on this machine, skipping execution."
+      end
+      puts
+      puts '=' * line_width
+      puts
+    end
 
   end
 
-  def rails_env_warning(socket_path)
+  def rails_env_check(socket_path)
+
+    line_width = 100
+
     envs = guessed_rails_envs(socket_path.dirname)
+
     if envs == [Rails.env]
-      # All good
+
+      :clearly_correct
+
+    elsif envs.empty?
+
+      puts
+      puts '*' * line_width
+      puts "WARNING: This Rails app seems not to run."
+      puts '*' * line_width
+      puts
+      :possible_correct
+
     elsif envs.include?(Rails.env)
-      puts '*' * 80
+
+      puts
+      puts '*' * line_width
       puts "INFO: Based on the socket paths #{socket_path.dirname},"
       puts "this Rails app may run in #{envs.join(' or ')}."
       puts "You are running as #{Rails.env} (Rails.env) which may be right."
-      puts '*' * 80
+      puts '*' * line_width
       puts
+      :possible_correct
+
     else
-      puts '*' * 80
+
+      puts
+      puts '*' * line_width
       puts "WARNING: You are running as #{Rails.env} (Rails.env)"
       puts "But the rails app seems to run in #{envs.join(' or ')}"
-      puts '*' * 80
+      puts '*' * line_width
       puts
+      :possible_wrong
+
     end
   end
 

data/templates/config_base/config/svelte_on_rails.yml

@@ -18,28 +18,42 @@ aliases:
   #'@frontend': app/frontend/javascript
   #'@views': app/views
 
-use_ssr_server: true
-# For performance reasons, it is recommended to use it.
-# Find more info on the docs.
+skip_ssr_header: 'X-Turbo-Request-ID'
+# when ssr: :auto =>
+# Skip SSR when this request header is present and non-empty (Turbo / prefetch / XHR requests)
+
+ssr: :auto
+# options: true, false, :auto
+# :auto: render server side if request is initial request (works only with turbo, because it checks for the X-Turbo-Request-ID header)
+# when not server-side rendered the components must be built as custom elements, see node-package @csedl/svelte-on-rails
+# false disables SSR for all and overrides the ssr argument of the view helper.
+
+ssr_server: true
+# Node server on the backend for speedup server side rendering
+# default: true for all environments, except test
+# docs: https://svelte-on-rails.dev/configuration/svelte_ssr_server.html
+
+ssr_server_workers: 1
+# number of Node cluster workers; 1 = no cluster
+
+ssr_fallback_renderer: false
+# Node script that does not need a running node server
+# default: false
+
+ssr_error_tag: true
+# Render the error tag when server side rendering fails
+# default: true, except for production
 
 # redis_cache_store:
 #   url: 'redis://localhost:6379/2'
 #   expires_in: 90.minutes (=> default / fallback: 1 hour)
 #   namespace: 'my-app-svelte-on-rails'
 
+
 use_caching: false
 # this is the default for the #svelte view-helper.
 # When set to true, the redis gem is required.
 
-ssr: :auto
-# options: true, false, :auto
-# :auto: render server side if request is initial request (works only with turbo, because it checks for the X-Turbo-Request-ID header)
-# when not server-side rendered the components must be built as custom elements, see node-package @csedl/svelte-on-rails
-
-skip_ssr_header: 'X-Turbo-Request-ID'
-# when ssr: :auto =>
-# Skip SSR when this request header is present and non-empty (Turbo / prefetch / XHR requests)
-
 debug: true
 # provides deeper logging with timestamps for performance improvements
 
@@ -81,4 +95,11 @@ test:
   watch_changes: true
   cache_expiration_hours: 15
 
-production:
+staging:
+  ssr_error_tag: true
+  ssr_fallback_renderer: false
+
+production:
+  ssr_error_tag: false
+  ssr_fallback_renderer: true
+  ssr_server_workers: 3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 20.0.18
+  version: 21.0.0
 platform: ruby
 authors:
 - Christian Sedlmair