svelte-on-rails 22.4.5 → 22.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c20418140ddcc6c13f764825f0fb67fc0753d5cf111b6ca4dd536c791b8aa15a
-  data.tar.gz: ffcee0dc8b10538a673c3c1e2992f11b2a1c3b03de2d06d761ddd7ebd343c3b9
+  metadata.gz: 1bcf2e7619271bc0d415deb797d15d3d7625640171fa02485fedded0bb526ac6
+  data.tar.gz: b7c3acb70f336fb7c9ff4b203474ed584c9ba280e7a080b959d50dc73e82e9e4
 SHA512:
-  metadata.gz: 6f3b8e485b02bc666cb9dcb6876941ab4c0781c9ab834e1fb5390a0327c83ba201f8d3e4219c4a0edd230e608f50d09b6508cd43dff25958f645ca402b489af9
-  data.tar.gz: b713bfea90974924c29f92374daa4196f7c15a70e9baf47fe7593048ac2af4f8c8b1b8917913de975bf80cc1a4f00c111fe03fbe3dc696fc9be9295dad6a2dab
+  metadata.gz: 4df7c21e84b8f1805b0e76fc11dccd5a890fc589399f7945763974f53038b6b595e3a5e834be13857ad0f1da0e20f718df0400cf3965ece7849265fe000c6e80
+  data.tar.gz: a7ad01afc86a956759a79d710806d162f10d7dc400fb0ab2801dd01ae5335d52976c292fb15a2c95bc18fd85dcdd0dd88ad158533c7228572f2121b479e0379d

data/lib/svelte_on_rails/lib/boot_context.rb

@@ -2,97 +2,64 @@ 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`.
+    # Returns true when we are certain the current process is a Puma web
+    # server (or a `rails server` process that will boot Puma). Everywhere
+    # else (rake, console, runner, tests, generators, unknown wrappers)
+    # returns false. False negatives are safe because the SsrClient has a
+    # lazy-start fallback that kicks in on the first render request.
     def serving_http?
-      # Explicit overrides for tests / edge cases:
-      return true  if ENV["SVELTE_ON_RAILS_FORCE_SSR"] == "1"
+      # 1. Explicit user overrides always win.
+      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.
+      # 2. Positive signal: `rails server` has been dispatched. This
+      #    constant is defined by Rails::Command::ServerCommand before the
+      #    app boots, and is a very reliable indicator.
+      return true if defined?(::Rails::Server)
+
+      # 3. Positive signal: a Puma::Launcher instance is already alive.
+      #    Puma instantiates its Launcher inside Puma::Runner#run, which
+      #    runs BEFORE Rails' after_initialize (because Puma requires the
+      #    Rack app, and requiring the app is what triggers Rails boot).
+      #    So by the time this method is called from our after_initialize
+      #    hook, the launcher exists in ObjectSpace iff we are inside Puma.
+      return true if puma_launcher_alive?
+
+      # 4. Positive signal: launched via `puma` / `pumactl` binary directly.
+      #    Redundant with (3) in most cases, but harmless and useful for
+      #    exotic launchers that bypass Puma::Runner.
+      return true if program_basename == "puma"
+
+      # Everything else: not an HTTP-serving context (as far as we can tell
+      # at boot time). If we're wrong, the lazy fallback will handle it.
       false
     end
 
+    # Short human-readable label for the log line when we skip SSR startup.
     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")
+      return "rails server"               if defined?(::Rails::Server)
+      return "puma"                       if puma_launcher_alive? || program_basename == "puma"
+      return "rake: #{Rake.application.top_level_tasks.join(', ')}" if rake_task?
+      return "rails console"              if defined?(::Rails::Console)
+      return "rails runner"               if defined?(::Rails::Command::RunnerCommand)
+      return "rails dbconsole"            if defined?(::Rails::DBConsole)
+      "program=#{program_basename}"
     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
+    def puma_launcher_alive?
+      return false unless defined?(::Puma::Launcher)
+      ObjectSpace.each_object(::Puma::Launcher).any?
+    rescue
+      false
     end
 
-    def server_program_name?
-      %w[puma rackup unicorn unicorn_rails falcon passenger].include?(program_basename)
+    def rake_task?
+      defined?(::Rake) && Rake.respond_to?(:application) &&
+        Rake.application.top_level_tasks.any?
     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

@@ -240,7 +240,7 @@ module SvelteOnRails
       def render_with_ssr_server(caller_loc)
         return {} unless @conf.configs[:ssr_server]
 
-        result = SvelteOnRails::SsrClient.instance.render(
+        result = SvelteOnRails::SsrClient.instance(caller: "Request/View-helper").render(
           component_paths,
           cached_props,
           debug?,

data/lib/svelte_on_rails/railtie.rb

@@ -23,7 +23,7 @@ module SvelteOnRails
           )
           $stdout.flush
         elsif SvelteOnRails::Configuration.instance.configs[:ssr]
-          SvelteOnRails::SsrClient.instance
+          SvelteOnRails::SsrClient.instance(caller: 'initializer/booting')
         end
 
       end
@@ -52,8 +52,9 @@ module SvelteOnRails
     end
 
     rake_tasks do
-      load File.expand_path("../../tasks/svelte_on_rails_tasks.rake", __FILE__)
+      load File.expand_path("../../tasks/general_tasks.rake", __FILE__)
       load File.expand_path("../../tasks/cache_tasks.rake", __FILE__)
+      load File.expand_path("../../tasks/ssr_client_tasks.rake", __FILE__)
     end
   end
 end

data/lib/svelte_on_rails/ssr_client.rb

@@ -10,34 +10,56 @@ module SvelteOnRails
                 :logfile_max_lines,
                 :socket_path,
                 :ssr_server_bin_path,
-                :node_bin
+                :node_bin,
+                :initialized_by,
+                :render_success_count,
+                :render_failure_count,
+                :error_log
 
     # methods
 
-    def self.instance
-      @instance ||= new
+    def self.instance(caller: nil)
+
+      @instance ||= new(caller: caller)
+      @instance
     end
 
-    def initialize
+    def initialize(caller: nil)
 
-      SvelteOnRails::Lib::Utils.ssr_server_logfile.delete if SvelteOnRails::Lib::Utils.ssr_server_logfile.exist?
+      @initialized_by = caller
 
-      @helpers = SsrServerHelpers.new
+      File.open(SvelteOnRails::Lib::Utils.ssr_server_logfile, 'w') do |f|
+        f.sync = true
+        f.puts("[#{Time.now.utc.iso8601(3)} ppid:#{Process.ppid} pid:#{Process.pid}]   >>>  Logfile deleted on initializing SsrClient, called by #{caller}  <<<")
+      end
+
+      @socket_namespace = [
+        "svelte",
+        Rails.application.class.module_parent_name[0..15],
+        SsrClientControlChannel.short_env
+      ].join("-")
+      @socket_path = socket_path_fresh
 
       @logfile_path = Rails.root.join("log/svelte-ssr-server-#{Rails.env}.log")
       @logfile_max_lines = build_logfile_max_lines
-      @socket_path = @helpers.socket_path
       @ssr_server = SvelteOnRails::Configuration.instance.configs[:ssr_server]
-      @ssr_server_bin_path = @helpers.ssr_server_bin_path
+      @ssr_server_bin_path = SvelteOnRails::Configuration.instance.ssr_server_bin_path
+      @started = Time.now
+
+      @render_success_count = 0
+      @render_failure_count = 0
+      @error_log = []
 
       File.delete(restart_marker_file) if File.exist?(restart_marker_file)
 
+      SvelteOnRails::SsrClientControlChannel.install_control_listener
+
       if @ssr_server
 
         start_node_server!
 
         at_exit do
-          @helpers.shutdown(caller: 'at_exit')
+          shutdown(caller: 'at_exit')
           File.delete(restart_marker_file) if File.exist?(restart_marker_file)
         end
       else
@@ -69,6 +91,9 @@ module SvelteOnRails
         socket.close
       rescue => e
 
+        write_error_log(e)
+        @render_failure_count += 1
+
         restart_my_server('Restart-after-failure')
 
         SvelteOnRails::Lib::Utils.error_log(
@@ -88,6 +113,7 @@ module SvelteOnRails
 
       raw_response = parse_body_json(response)
       if raw_response['status'] == 'SUCCESS'
+        @render_success_count += 1
         htm = raw_response['html'].to_s
                                   .gsub('<!--[-->', '')
                                   .gsub('<!--]-->', '')
@@ -108,6 +134,10 @@ module SvelteOnRails
                else
                  ''
                end
+
+        write_error_log("Render #{component[:file_basename]}.svelte")
+        @render_failure_count += 1
+
         utils = SvelteOnRails::Lib::Utils
         utils.error_log(
           :render_failed,
@@ -124,6 +154,12 @@ module SvelteOnRails
 
     end
 
+    def write_error_log(msg)
+      timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S.%3N')
+      @error_log << "[#{timestamp}] #{msg}"
+      @error_log.shift while @error_log.size > 50
+    end
+
     def parse_body_json(response_string)
       return {} unless response_string.to_s.present?
 
@@ -169,21 +205,12 @@ module SvelteOnRails
 
       SvelteOnRails::Lib::Utils.ssr_server_log("SOR start_node_server! called", ssr_logfile_only: !restart_after_failure)
 
-      # notice ppid
-      FileUtils.mkdir_p(@helpers.ssr_client_ppid_file.dirname)
-      File.write(@helpers.ssr_client_ppid_file, Process.ppid.to_s)
-      if @helpers.ssr_client_ppid_file.exist?
-        SvelteOnRails::Lib::Utils.ssr_server_log("File #{@helpers.ssr_client_ppid_file} written, PPID: #{Process.ppid}", ssr_logfile_only: true)
-      else
-        SvelteOnRails::Lib::Utils.ssr_server_log("ERROR: File #{@helpers.ssr_client_ppid_file} could not be written")
-      end
-
       start = Time.now
 
       @node_server_output = {}
       Thread.new do
         stdout, stderr, status = Open3.capture3(
-          @helpers.start_node_server_command(started_by),
+          start_node_server_command(started_by),
           chdir: Rails.root
         )
         @node_server_output = {
@@ -215,7 +242,7 @@ module SvelteOnRails
       end
       SvelteOnRails::Lib::Utils.ssr_server_log("Server responded successfully")
 
-      @helpers.cleanup_leftover_processes
+      cleanup_leftover_processes
     end
 
     def restart_my_server(tag = nil)
@@ -234,7 +261,7 @@ module SvelteOnRails
       Rails.logger.error(msg)
       SvelteOnRails::Lib::Utils.ssr_server_log("[ERROR] #{msg}")
 
-      @helpers.shutdown(caller: 'restart')
+      shutdown(caller: 'restart')
       begin
         start_node_server!("#{tag.gsub(' ', '-') + '-' if tag}#{count}", restart_after_failure: true)
       rescue
@@ -253,6 +280,57 @@ module SvelteOnRails
       nil
     end
 
+    def uptime
+      Time.now - @started
+    end
+
+    def start_node_server_command(started_by = '')
+      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,
+        (workers > 1 ? "--workers=#{workers}" : nil)
+      ].compact.join(' ')
+    end
+
+    def shutdown(caller: '')
+      SsrClient.instance_variable_set(:@instance, nil)
+      SvelteOnRails::Lib::Utils.ssr_server_log("Shutting down SSR client, ppid: #{Process.ppid} (#{caller})")
+      terminate_node_processes(own_processes, label: "own")
+      {
+        success: true
+      }
+    rescue => e
+      {
+        error: e
+      }
+    end
+
+    # NODE PROCESS MANAGEMENT
+
+    SsrProcess = Struct.new(:pid, :ppid, :socket_path, keyword_init: true)
+
+    def own_processes
+      scan_processes.select { |p| p.ppid == Process.ppid }
+    end
+
+    def leftover_processes
+      scan_processes.reject { |p| p.ppid == Process.ppid }
+    end
+
+    def leftover_sockets
+      scan_sockets.reject { |s| s[:ppid] == Process.ppid }
+    end
+
+    def cleanup_leftover_processes
+      terminate_node_processes(leftover_processes, label: "leftover")
+      delete_sockets(leftover_sockets.map { |s| s[:path] }, label: "leftover")
+    end
+
+    # END node process management
+
     private
 
     def restart_marker_file
@@ -325,91 +403,24 @@ module SvelteOnRails
       end
     end
 
-  end
-
-  class SsrServerHelpers
-
-    # theese helpers are used from the :check rake task
-    # For that reason they are within a separate class
-
-    attr_reader :socket_namespace,
-                :socket_path,
-                :ssr_server_bin_path
-
-    def initialize
-
-      @socket_namespace = [
-        "svelte-ssr",
-        Rails.application.class.module_parent_name[0..30],
-        Rails.env,
-      ].join("-")
-
-      @ssr_server_bin_path = SvelteOnRails::Configuration.instance.ssr_server_bin_path
-
-    end
-
-    def ssr_client_ppid_file
-      Rails.root.join("tmp", "pids", 'svelte_on_rails.ppid')
-    end
-
-    def socket_path(ppid: Process.ppid)
+    def socket_path_fresh
+      ppid = Process.ppid
       app_sock = Rails.root.join("tmp/sockets/#{@socket_namespace}-#{ppid}.sock")
-      FileUtils.mkdir_p(File.dirname(app_sock))
-
-      return app_sock if app_sock.to_s.length < 104
+      if app_sock.to_s.length <= 103
+        FileUtils.mkdir_p(File.dirname(app_sock))
+        return app_sock
+      end
 
-      # Fallback: socket paths > 104 chars are unreliable on macOS/BSD
+      # Fallback: socket paths > 103 chars are unreliable on macOS/BSD
       FileUtils.rm_f(app_sock) if File.exist?(app_sock)
-      dir = File.expand_path("/tmp/svelte")
-      FileUtils.mkdir_p(dir)
-      FileUtils.chmod(0777, dir)
-      fallback = Pathname.new("#{dir}/#{@socket_namespace}-#{ppid}.sock")
-      SvelteOnRails::Lib::Utils.ssr_server_log("sockets longer than 104 chars are risky, fallback to: #{fallback}")
+      fallback = Pathname.new("/tmp/#{@socket_namespace}-#{ppid}.sock")
+      SvelteOnRails::Lib::Utils.ssr_server_log("sockets longer than 103 chars are risky, fallback to: #{fallback}")
       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
+    # NODE PROCESS MANAGEMENT
 
-    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, caller: '')
-      SvelteOnRails::Lib::Utils.ssr_server_log("Shutting down SSR client, ppid: #{current_ppid} (#{caller})")
-      terminate_processes(own_processes(current_ppid: current_ppid), label: "own")
-    ensure
-      File.delete(ssr_client_ppid_file) if File.exist?(ssr_client_ppid_file)
-    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:)
+    def terminate_node_processes(processes, label:)
       return if processes.empty?
 
       processes.group_by(&:socket_path).values.flat_map { |g| g.sort_by(&:pid) }.each do |p|
@@ -432,7 +443,6 @@ module SvelteOnRails
       SvelteOnRails::Lib::Utils.ssr_server_log("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}
@@ -444,16 +454,115 @@ module SvelteOnRails
       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"]
+      dirs = [Rails.root.join("tmp/sockets").to_s, "/tmp"]
       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 node process management
+
+  end
+
+  class SsrClientControlChannel
+
+    # Full path of the control socket.
+    # Sits next to the SSR socket in tmp/sockets, or in the /tmp/svelte
+    # fallback directory when Rails.root pushes total length over 103 chars.
+    def self.socket_path
+      primary = Rails.root.join("tmp", "sockets", "svelte-ctl-#{short_env}.sock")
+      if primary.to_s.length <= 103
+        FileUtils.mkdir_p(File.dirname(primary))
+        return primary
+      end
+
+      Pathname.new("/tmp/svelte-#{short_env}-ctl-#{Digest::XXH64.hexdigest(Rails.root.to_s)}.sock")
+    end
+
+    # enable communication by rake task for admin purposes
+    def self.install_control_listener
+
+      path = socket_path.to_s
+      FileUtils.mkdir_p(File.dirname(path))
+      File.unlink(path) if File.exist?(path)
+
+      server = UNIXServer.new(path)
+      File.chmod(0600, path)
+
+      Thread.new do
+        loop do
+          client = server.accept
+          begin
+            request = client.gets&.strip.to_sym
+            client_instance = SsrClient.instance(caller: 'rake task (manual)')
+
+            response = case request
+                       when :status
+                         {
+                           env: Rails.env,
+                           uptime: client_instance.uptime,
+                           request: request,
+                           socket_path: client_instance.socket_path,
+                           initialized_by: client_instance.initialized_by,
+                           ping: client_instance.ping?,
+                           start_node_server_command: client_instance.start_node_server_command,
+                           render_success_count: client_instance.render_success_count,
+                           render_failure_count: client_instance.render_failure_count,
+                           error_log: client_instance.error_log
+                         }
+                       when :stop
+                         begin
+                           client_instance.shutdown
+                           {
+                             success: true
+                           }
+                         rescue => e
+                           {
+                             error: "Failed to stop SSR server => #{e}"
+                           }
+                         end
+                       end
+
+            client.puts(response.to_json)
+          rescue => e
+            SvelteOnRails::Lib::Utils.ssr_server_log(
+              "[control] handler error: #{e.class}: #{e.message}",
+              ssr_logfile_only: true
+            )
+          ensure
+            client.close rescue nil
+          end
+        end
+      end
+
+      at_exit do
+        server.close rescue nil
+        File.unlink(path) rescue nil
+      end
+
+      SvelteOnRails::Lib::Utils.ssr_server_log(
+        "Control listener installed on #{path}",
+        ssr_logfile_only: true
+      )
+
+    end
+
+    def self.short_env
+
+      name = Rails.env.to_s
+
+      short = {
+        "development" => "dev",
+        "production" => "prod",
+        "staging" => "stage",
+      }[name]
+
+      return name unless short
+      return name if Rails.root.join("config", "environments", "#{short}.rb").exist?
+      short
+    end
   end
 
   class SsrError < StandardError; end

data/lib/tasks/general_tasks.rake

@@ -0,0 +1,10 @@
+namespace :svelte_on_rails do
+  desc "Precompile Svelte components for server side rendering"
+  task :precompile do
+    SvelteOnRails::Configuration.instance.vite_build
+  end
+
+
+
+end
+Rake::Task["assets:precompile"].enhance ["svelte_on_rails:precompile"]

data/lib/tasks/ssr_client_tasks.rake

@@ -0,0 +1,111 @@
+namespace :svelte_on_rails do
+
+  desc "Check svelte-on-rails setup and SSR server status"
+  task :check do
+
+    @line_width = 130
+
+    # SSR CLIENT STATUS
+
+    cs = get_from_ssr_client(:status)
+    exit(1) unless cs
+    client_status = JSON.parse(cs).symbolize_keys
+    configs = SvelteOnRails::Configuration.instance
+    socket_path = client_status[:socket_path]
+
+    puts
+    puts '=' * @line_width
+    puts
+    puts "INFO FROM THE SSR CLIENT (Rails-side):"
+    puts
+    puts "  Rails env            : #{client_status[:env]}"
+    puts "  Initialized by       : #{client_status[:initialized_by]}"
+    puts "  Uptime               : #{client_status[:uptime].round(0)} sec"
+    puts '  Node version         : ' + configs.node_version_test
+    puts '  Node bin             : ' + configs.node_bin_path.to_s
+    puts '  NPM package version  : ' + configs.npm_package_version_test.to_s
+    puts '  SSR Server bin       : ' + configs.ssr_server_bin_path.to_s
+    puts "  Socket (SsrServer)   : #{socket_path} (#{File.socket?(socket_path) ? 'Present/OK' : 'NOT FOUND!'})"
+    puts "  Ping to SsrServer    : #{client_status[:ping] ? 'SUCCESS' : 'FAILED'}"
+    puts "  SSR renders          : #{client_status[:render_success_count]} succeeded, #{client_status[:render_failure_count]} failed"
+    puts
+
+    # NODE SERVER STATUS
+
+    curl_installed = system('which curl > /dev/null 2>&1')
+    if !curl_installed
+      puts '*' * @line_width
+      puts '  ERROR'
+      puts '  curl is not installed on this machine.'
+      puts '  unable to check node server status.'
+      puts '*' * @line_width
+      exit(1)
+    else
+      puts '=' * @line_width
+      puts
+      puts "SSR SERVER (NODE) STATUS:"
+      puts
+      curl_cmd = "curl --unix-socket #{socket_path} http://localhost"
+      stdout, stderr, status = Open3.capture3(curl_cmd)
+      puts stdout
+      puts
+    end
+
+    puts '=' * @line_width
+    puts
+    puts 'ADDITIONAL INFO:'
+    puts
+    if client_status[:error_log] == []
+      puts 'No error logs on the client side (Ruby).'
+    else
+      puts "#{client_status[:error_log].length} Errors (Limited to 50):"
+      puts "  #{client_status[:error_log].reverse.join("\n  ")}"
+    end
+    puts
+    puts 'How was the node bin path determined:'
+    configs.instance_variable_get(:@node_bin_path_log).each_with_index do |line, index|
+      puts "  #{index + 1} #{line}"
+    end
+    puts
+    puts 'Commands:'
+    puts "  • start node server (node path/to/svelte-ssr-server.js path/to/socket.sock):"
+    puts "    • #{client_status[:start_node_server_command]}"
+    puts
+    puts '=' * @line_width
+    puts
+
+  end
+
+  namespace :ssr_client do
+
+    desc 'For development: to simulate when a client did not start on deploy (Then, on the first request of a svelte component - if not cached! - it must start)'
+    task :stop do
+      r = get_from_ssr_client(:stop)
+      if r['success']
+        puts "SSR client stopped successfully."
+      else
+        puts "ERROR: #{r}"
+      end
+    end
+
+  end
+
+  def get_from_ssr_client(request)
+
+    raise "invalid request" unless [:status, :stop].include?(request)
+
+    path = SvelteOnRails::SsrClientControlChannel.socket_path.to_path
+    unless File.socket?(path)
+      puts "*" * @line_width
+      puts "ERROR: Control socket not found at #{path} — is Rails running?"
+      puts "*" * @line_width
+      return
+    end
+
+    sock = UNIXSocket.new(path)
+    sock.puts(request)
+    response = sock.gets
+    sock.close
+    response
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 22.4.5
+  version: 22.5.1
 platform: ruby
 authors:
 - Christian Sedlmair
@@ -102,7 +102,8 @@ files:
 - 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
+- lib/tasks/general_tasks.rake
+- lib/tasks/ssr_client_tasks.rake
 - templates/config_base/app/frontend/ssr/ssr.js
 - templates/config_base/config/svelte_on_rails.yml
 - templates/config_base/tsconfig.json

data/lib/tasks/svelte_on_rails_tasks.rake

@@ -1,108 +0,0 @@
-namespace :svelte_on_rails do
-  desc "Precompile Svelte components for server side rendering"
-  task :precompile do
-    SvelteOnRails::Configuration.instance.vite_build
-  end
-
-  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)
-
-    unless File.socket?(socket_path)
-      puts "*" * 80
-      puts "ERROR: socket file does not exist or is not a socket: #{socket_path}"
-      puts "Do you have set RAILS_ENV correctly?"
-      puts "*" * 80
-    end
-
-    unless ppid_file.exist?
-      puts "*" * 80
-      puts "ERROR: PPID File does not exist: #{ppid_file}"
-      puts "Is the app running?"
-      puts "*" * 80
-    end
-
-    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
-
-    puts
-    puts '=' * line_width
-    puts "Svelte on Rails SSR Server Status:"
-    puts "  Rails env: #{Rails.env}"
-    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
-    puts label('Node version') + configs.node_version_test
-    puts label('SSR Server bin') + configs.ssr_server_bin_path.to_s
-    puts label('SSR Server version') + configs.npm_package_version_test.to_s
-    puts
-    puts 'Rails instance'
-    puts label('Process.ppid') + ppid.to_s
-    puts label('Socket') + socket_path.to_s
-    puts
-    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
-
-    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
-
-  def label(msg)
-    l = msg.length
-    "  #{msg}:"[0..20] + (msg.length > 22 ? ':' : '') + ' ' * (20 - l)
-  end
-
-end
-
-Rake::Task["assets:precompile"].enhance ["svelte_on_rails:precompile"]