svelte-on-rails 19.2.4 → 20.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0651050b86e2825987db63e71145cf7d2d572530073b5012a2fa2bbeca42befc
-  data.tar.gz: 18465ac8ec33e475fb60109ceefe7b9f19d165e298cca6c2ed8c150bef3e7764
+  metadata.gz: e61898f85783b55d7c82ac30d42e8aa73bcbdb1fa99a250691f82b712f81e975
+  data.tar.gz: b44558fa104458637bde419dc7a97ce68e6dee4e5b2814d1c41ed16210795af5
 SHA512:
-  metadata.gz: a1839966afa9e6d1a61fdcbb39dd1864571eee64898f15db7294111c07dec2b1eb7b7c8d59290e62cd2b315404430abfe7f0727ba3b6c671b6d4715db93e3345
-  data.tar.gz: bd6ad6d60dcda1a6d365aabe5806f808fc74c1e82b6a7070c99be07bad6b14622cc12d4c9d448bafe6a6cfb47a17a5fe2bd812364cc87cac1919df6231c4b9e4
+  metadata.gz: 493f5ab74088598e9b8a1d89e6e27ee32009545ec9d438040ee405a8d07fc791b77632f61377c18b71d4bee4a51fc599ad389a784198e0b370d398e437814174
+  data.tar.gz: 0e5ca1c8a2d9e60ccb1206871c10bba3ab2d42322b1f2e8982b7e06f988848bee518075b72ce1e2c5c7e4e2657c5716bf8505dc50cdbfb7a7fed516a5c4d923e

data/lib/svelte_on_rails/configuration.rb

@@ -135,46 +135,7 @@ module SvelteOnRails
     end
 
     def node_bin_path
-      @node_bin_path ||= begin
-                           n = ENV['SVELTE_ON_RAILS_NODE_BIN'] || 'node'
-
-                           if n == 'node'
-                             nvm_installed = false
-                             nvm_dir = ENV['NVM_DIR'] || File.expand_path('~/.nvm')
-                             nvm_installed ||= File.exist?("#{nvm_dir}/nvm.sh")
-
-                             if nvm_installed
-                               # Check for .nvmrc in the project root
-                               project_root = rails_root || Dir.pwd
-                               nvmrc_path = File.join(project_root, '.nvmrc')
-                               use_nvmrc = File.exist?(nvmrc_path)
-
-                               if use_nvmrc
-                                 # Read the version from .nvmrc
-                                 node_version = File.read(nvmrc_path).strip
-                                 # Ensure NVM is sourced and use the version from .nvmrc
-                                 command = "[ -s \"#{nvm_dir}/nvm.sh\" ] && . \"#{nvm_dir}/nvm.sh\" && nvm use #{node_version} > /dev/null 2>&1 && nvm which #{node_version}"
-                               else
-                                 # Fallback to current NVM version
-                                 command = "[ -s \"#{nvm_dir}/nvm.sh\" ] && . \"#{nvm_dir}/nvm.sh\" && nvm which current"
-                               end
-
-                               node_path, status = Open3.capture2("bash -lc '#{command}'")
-
-                               # Only update n if the command succeeded and output is non-empty
-                               n = node_path.strip if status.success? && !node_path.strip.empty?
-                             end
-                           end
-
-                           # Validate node_bin
-                           unless n && !n.empty? && system("#{n} --version > /dev/null 2>&1")
-                             raise "Node.js not found at '#{n || 'unknown'}'. Please configure SVELTE_ON_RAILS_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 alias default <version>` to set a default version or ensure a valid .nvmrc file is present."
-                           end
-
-                           n
-                         rescue StandardError => e
-                           raise "Failed to detect Node.js binary: «#{e.message}». Ensure Node.js is installed and accessible, or set SVELTE_ON_RAILS_NODE_BIN. If using .nvmrc, ensure the specified version is installed via NVM."
-                         end
+      @node_bin_path ||= resolve_node_bin_path
     end
 
     def initialize_request_metrics(request_uuid)
@@ -187,6 +148,16 @@ module SvelteOnRails
 
     end
 
+    def node_version_test
+      `#{node_bin_path} --version`.chomp
+    end
+
+    def npm_package_version_test
+      JSON.parse(File.read(Rails.root.join('node_modules/@csedl/svelte-on-rails/package.json')))['version']
+    rescue
+      nil
+    end
+
     private
 
     def redis_cache_store_configs
@@ -305,12 +276,58 @@ 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('13.1.0')
-          raise "[Svelte-on-Rails] NPM-Package @csedl/svelte-on-rails: At least version 13.1.0 is required, but found: «#{sor}»"
+        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}»"
+        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")}"
         end
       end
 
     end
 
+    def resolve_node_bin_path
+      @node_bin_path_log = []
+
+      if (ev = ENV['SVELTE_ON_RAILS_NODE_BIN']).present?
+        @node_bin_path_log << "environment variable SVELTE_ON_RAILS_NODE_BIN present"
+        return ev
+      end
+      @node_bin_path_log << "environment variable SVELTE_ON_RAILS_NODE_BIN not present"
+
+      nvm_dir = ENV['NVM_DIR'] || File.expand_path('~/.nvm')
+      unless File.exist?(File.join(nvm_dir, 'nvm.sh'))
+        @node_bin_path_log << "nvm not installed, fallback to «node»"
+        return 'node'
+      end
+      @node_bin_path_log << "nvm installed, found by #{ENV['NVM_DIR'] ? 'NVM_DIR' : '~/.nvm'}"
+
+      command = build_nvm_command(nvm_dir)
+      node_path, status = Open3.capture2('bash', '-lc', command)
+
+      if status.success? && !node_path.strip.empty?
+        @node_bin_path_log << "SUCCESS: bash -lc «#{command}»"
+        node_path.strip
+      else
+        @node_bin_path_log << "bash -lc «#{command}» FAILED, fallback to «node»"
+        'node'
+      end
+    end
+
+    def build_nvm_command(nvm_dir)
+      nvmrc_path = File.join(rails_root || Dir.pwd, '.nvmrc')
+      nvm_sh = Shellwords.escape(File.join(nvm_dir, 'nvm.sh'))
+
+      if File.exist?(nvmrc_path)
+        @node_bin_path_log << "found .nvmrc in project root, checking version there"
+        version = Shellwords.escape(File.read(nvmrc_path).strip)
+        %([ -s #{nvm_sh} ] && . #{nvm_sh} && nvm use #{version} > /dev/null 2>&1 && nvm which #{version})
+      else
+        @node_bin_path_log << ".nvmrc not found in project root, using current NVM version"
+        %([ -s #{nvm_sh} ] && . #{nvm_sh} && nvm which current)
+      end
+    end
+
   end
 end

data/lib/svelte_on_rails/installer/utils.rb

@@ -285,7 +285,7 @@ module SvelteOnRails
           files.each do |f|
 
             unless ssr_server_configured
-              next if File.basename(f) == File.basename(SvelteOnRails::SsrServer.script_path_full)
+              next if File.basename(f) == File.basename(SvelteOnRails::SsrServer.ssr_server_bin_path)
             end
 
             paths.push(

data/lib/svelte_on_rails/lib/fallback_renderer.rb

@@ -39,6 +39,7 @@ module SvelteOnRails
 
           {
             success: true,
+            fallback: true,
             html: htm,
             head: js['head'],
           }

data/lib/svelte_on_rails/lib/view_helper_support.rb

@@ -154,7 +154,8 @@ module SvelteOnRails
       def log_completed(message)
         ms = ((Time.now - @start_time) * 1000)
         @conf.request_metrics[:total_time] += ms
-        Rails.logger.info "  [SOR] #{component_paths[:name]}.svelte #{message} (#{ms.round(1)}ms)"
+        msg = "  [SOR] #{component_paths[:name]}.svelte #{message} (#{ms.round(1)}ms)"
+        Rails.logger.info msg
       end
 
       def render_svelte(current_template)
@@ -191,10 +192,8 @@ module SvelteOnRails
         # render
 
         res = if @cached_content
-                msg = "returned from cache#{", with uncached props" if @cached_props.key?(:_uncached)}"
                 @cached_content.html_safe
               else
-                msg = "Rendered"
                 @skip_caching = false
                 @conf.debug_log(debug?, component_paths[:name], "rendered and stored to cache (key: «#{cache_key}»)") do
                   r = view_context.instance_eval(&block)
@@ -204,7 +203,6 @@ module SvelteOnRails
                   r
                 end
               end
-        log_completed(msg)
         res
 
       end

data/lib/svelte_on_rails/railtie.rb

@@ -20,14 +20,6 @@ module SvelteOnRails
 
         ActiveRecord::Base.extend SvelteOnRails::ActiveRecordOptIn
 
-        # # Include instance-level extensions for ActiveRecord instances (e.g., @article)
-        # include SvelteOnRails::ActiveRecordExtensions
-        #
-        # # Extend ActiveRecord::Base with class-level extensions (e.g., Article)
-        # ActiveRecord::Base.extend SvelteOnRails::ActiveRecordClassExtensions
-
-        # This also extends ActiveRecord::Relation (e.g., @articles)
-        #ActiveRecord::Relation.include SvelteOnRails::ActiveRecordRelationExtensions
       end
     end
 

data/lib/svelte_on_rails/ssr_server.rb

@@ -1,84 +1,48 @@
 require 'singleton'
 
 module SvelteOnRails
+
   class SsrServer
 
     include Singleton
 
-    attr_reader :connection
-
-    # parameter
-
-    def logfile_max_lines
-      if Rails.env.test?
-        20
-      elsif Rails.env.development?
-        50
-      elsif Rails.env.production?
-        1000
-      else
-        100
-      end
-    end
-
-    def logfile_path
-      Rails.root.join("log/svelte-ssr-server-#{Rails.env}.log")
-    end
-
-    def socket_path
-      @socket_path ||= begin
-
-                         app_sock = Rails.root.join("tmp/sockets/#{@socket_namespace}-#{Process.pid}.sock").to_s
-                         preferred_dir = File.dirname(app_sock)
-                         FileUtils.mkdir_p(preferred_dir)
-
-                         if app_sock.to_s.length < 104
-                           app_sock
-                         else
-                           FileUtils.rm_f(app_sock) if File.exist?(app_sock)
-                           # Fallback to shorter path in /tmp
-                           dir = File.expand_path("/tmp/svelte")
-                           FileUtils.mkdir_p(dir)
-                           FileUtils.chmod(0777, dir)
-                           s = dir + "/#{@socket_namespace}-#{Process.pid}.sock"
-                           start_server_log(nil, "sockets longer than 104 chars are risky, fallback to: #{s}")
-                           s
-                         end
-
-                       end
-    end
-
-    def self.script_path_full
-      Rails.root.join(script_path)
-    end
-
-    def self.script_path
-      Pathname('node_modules/@csedl/svelte-on-rails/bin/svelte-ssr-server.js')
-    end
+    attr_reader :socket_namespace,
+                :logfile_path,
+                :logfile_max_lines,
+                :socket_path,
+                :ssr_server_bin_path,
+                :node_bin,
+                :ssr_server_ppid_file
 
     # methods
 
-    def self.instance
-      @instance ||= new
+    def self.instance(dry_run_ppid: nil)
+      @instance ||= new(dry_run_ppid: dry_run_ppid)
     end
 
-    def initialize
+    def initialize(dry_run_ppid: nil)
 
       @socket_namespace = [
         "svelte-ssr",
         Rails.application.class.module_parent_name[0..30],
         Rails.env,
       ].join("-")
+      @dry_run_ppid = dry_run_ppid if dry_run_ppid
 
-      @utils = SvelteOnRails::Lib::Utils
+      @logfile_path = Rails.root.join("log/svelte-ssr-server-#{Rails.env}.log")
+      @logfile_max_lines = build_logfile_max_lines
+      @socket_path = build_socket_path
+      @use_ssr_server = SvelteOnRails::Configuration.instance.configs[:use_ssr_server]
+      @node_bin = SvelteOnRails::Configuration.instance.node_bin_path
+      @ssr_server_bin_path = Rails.root.join(Pathname('node_modules/@csedl/svelte-on-rails/bin/svelte-ssr-server.js'))
+      @ssr_server_ppid_file = Rails.root.join("tmp", "pids", 'svelte_on_rails.ppid')
 
-      @config = SvelteOnRails::Configuration.instance
-      if @config.configs[:use_ssr_server] && defined?(Rails::Server)
+      if @use_ssr_server && defined?(Rails::Server)
 
         start_node_server!
 
         at_exit do
-          Process.kill("SIGINT", (node_server_pid || 0)) if node_server_pid
+          kill_my_server
         end
       end
 
@@ -87,7 +51,7 @@ module SvelteOnRails
     def render(component, props, debug, view_path_proc)
 
       # fetch asset
-      manifest = @config.manifest(debug, component[:name])
+      manifest = SvelteOnRails::Configuration.instance.manifest(debug, component[:name])
       _asset_path = manifest[component[:path]]['file']
       full_asset_path = Rails.root.join('public', 'svelte-ssr', _asset_path)
 
@@ -119,6 +83,7 @@ module SvelteOnRails
         else
           raise e
         end
+        restart_my_server
       end
 
       shorten_logfile
@@ -150,7 +115,7 @@ module SvelteOnRails
           :render_failed,
           "Render #{component[:file_basename]}.svelte",
           [
-            raw_response['errorLog'].to_a.join("\n"),
+            raw_response['logs'].to_a.join("\n"),
             "View:\n#{view_path_proc.call}\nComponent:\n#{Rails.root.join(component[:path]).to_s}#{imps}",
           ]
         )
@@ -172,7 +137,7 @@ module SvelteOnRails
     end
 
     def configured?
-      @configured ||= File.exist?(self.class.script_path_full)
+      @configured ||= File.exist?(@ssr_server_bin_path)
     end
 
     def ping?
@@ -184,7 +149,7 @@ module SvelteOnRails
       response = ''
       begin
         sock = UNIXSocket.new(socket_path)
-        request = "GET /ping HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"
+        request = "GET /health HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"
         sock.write(request)
         response = sock.read
         sock.close
@@ -192,18 +157,28 @@ module SvelteOnRails
         puts "[SOR] Ping Failed: #{e.message}"
       end
       if response.match?(/^HTTP\/\d\.\d 200/)
-        @alive = true
+        r = parse_body_json(response)
+        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'
       end
     end
 
-    def start_node_server!
+    def start_node_server!(started_by = "rails-boot-#{Rails.env}-#{Process.ppid}")
+
+      # notice ppid
+      unless @dry_run_ppid
+        FileUtils.mkdir_p(@ssr_server_ppid_file.dirname)
+        File.write(@ssr_server_ppid_file, Process.ppid.to_s)
+      end
 
-      cnf = SvelteOnRails::Configuration.instance
       start = Time.now
       cmd = [
-        "SVELTE_SSR_SERVER_LOGFILE=#{logfile_path}",
-        "#{cnf.node_bin_path} #{self.class.script_path}",
-        "#{socket_path}"
+        "SVELTE_SSR_SERVER_STARTED_BY=r#{started_by}",
+        @node_bin,
+        @ssr_server_bin_path,
+        @socket_path
       ].join(' ')
 
       @node_server_output = {}
@@ -218,6 +193,7 @@ 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...")
 
       until node_server_pid do
@@ -225,11 +201,10 @@ module SvelteOnRails
         start_server_log(start, "Waiting for node server process-id")
         start_server_timeout!(start)
       end
-      start_server_log(start, "Node-server process-id: #{node_server_pid}")
 
       until File.exist?(socket_path) do
-        sleep 0.05
-        start_server_log(start, "Waiting for socket to be created #{socket_path}")
+        sleep 0.1
+        start_server_log(start, "Waiting for socket to be created")
         start_server_timeout!(start)
       end
       start_server_log(start, "Socket created: #{socket_path}")
@@ -251,7 +226,7 @@ module SvelteOnRails
 
       leftover = stdout.split("\n").map do |line|
         if line.match?(/\/#{@socket_namespace}-[0-9]+.sock$/)
-          unless line.include?("#{@socket_namespace}-#{Process.pid}.sock")
+          unless line.match?(/\/#{@socket_namespace}-#{Process.ppid}.sock$/)
             line.match(/[0-9]+/).to_s.to_i
           end
         end
@@ -264,6 +239,25 @@ module SvelteOnRails
       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(@ssr_server_ppid_file)
+    rescue
+
+    end
+
+    def restart_my_server
+      return unless @server_restarted_time > 1.minutes.ago
+      @server_restarted_count ||= 1
+      kill_my_server
+      begin
+        start_node_server!("Restart-after-failure-#{@server_restarted_count}")
+        @server_restarted_time = Time.now
+        @server_restarted_count += 1
+      rescue
+      end
+    end
+
     def alive?
       @alive
     end
@@ -273,7 +267,7 @@ module SvelteOnRails
         "ps aux | grep svelte"
       )
       stdout.split("\n").each do |line|
-        if line.include?("#{@socket_namespace}-#{Process.pid}.sock")
+        if line.include?("#{@socket_namespace}-#{Process.ppid}.sock")
           return line.match(/[0-9]+/).to_s.to_i
         end
       end
@@ -294,7 +288,7 @@ module SvelteOnRails
     def start_server_timeout!(start_time, timeout: 2000)
       ms = ((Time.now - start_time) * 1000).round(1)
       if ms > timeout
-        @utils.error_log(
+        SvelteOnRails::Lib::Utils.error_log(
           :ssr_server_unreachable,
           'SSR Server could not be started. ',
           [
@@ -346,7 +340,36 @@ module SvelteOnRails
       end
     end
 
+    def build_logfile_max_lines
+      if Rails.env.test?
+        20
+      elsif Rails.env.development?
+        50
+      elsif Rails.env.production?
+        1000
+      else
+        100
+      end
+    end
+
+    def build_socket_path
+      app_sock = Rails.root.join("tmp/sockets/#{@socket_namespace}-#{@dry_run_ppid || Process.ppid}.sock").to_s
+      FileUtils.mkdir_p(File.dirname(app_sock))
+
+      return app_sock if app_sock.length < 104
+
+      # Fallback: socket paths > 104 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 = "#{dir}/#{@socket_namespace}-#{@dry_run_ppid || Process.ppid}.sock"
+      start_server_log(nil, "sockets longer than 104 chars are risky, fallback to: #{fallback}")
+      fallback
+    end
+
   end
 
   class SsrError < StandardError; end
+
 end

data/lib/svelte_on_rails/view_helpers.rb

@@ -32,19 +32,22 @@ module SvelteOnRails
       if support.ssr?
         if config.watch_changes? && !config.build_status['passed']
           sor_error_tag(support, wrapper_html, component_props, 'server-side-svelte-build-error', 'SVELTE BUILD FAILED')
+
         elsif caching
           support.set_request_metrics(:from_cache)
           if component_props.key?(:_uncached)
 
+            # With Caching:
             # when we have uncached props, we do not cache the wrapper tag
 
             attr = support.tag_attributes(wrapper_html, component_props)
-            content_tag(:div, attr) do
+            r = content_tag(:div, attr) do
               support.render_cached(self) do
-                res = support.render_svelte(@current_template)
-                if res[:success]
-                  concat(res[:head].html_safe)
-                  concat(res[:html].html_safe)
+                rnd = support.render_svelte(@current_template)
+                if rnd[:success]
+                  concat(rnd[:head].html_safe)
+                  concat(rnd[:html].html_safe)
+                  support.log_completed("returned from cache, with uncached props#{', (Fallback!)' if rnd[:fallback]}")
                 else
                   sor_error_tag(support, wrapper_html, component_props, 'server-side-svelte-render-error', 'SVELTE RENDER FAILED')
                 end
@@ -53,26 +56,47 @@ module SvelteOnRails
 
           else
 
+            # With Caching:
             # when all props are cached, we can cache the wrapper tag too
             # ... but using only cached props for making sure we don't cache any dynamic content
 
-            support.render_cached(self) do
-              res = support.render_svelte(@current_template)
-              if res[:success]
+            log = 'returned from cache'
+            res = support.render_cached(self) do
+              rnd = support.render_svelte(@current_template)
+              if rnd[:success]
                 attr = support.tag_attributes(wrapper_html, support.cached_props)
-                content_tag(:div, attr) do
-                  concat(res[:head].html_safe)
-                  concat(res[:html].html_safe)
+                log = "rendered#{' (Fallback!) and stored to cache' if rnd[:fallback]}"
+                r = content_tag(:div, attr) do
+                  concat(rnd[:head].html_safe)
+                  concat(rnd[:html].html_safe)
                 end
+
+                r
               else
+                log = "ERROR"
                 sor_error_tag(support, wrapper_html, component_props, 'server-side-svelte-render-error', 'SVELTE RENDER FAILED')
               end
             end
-
+            support.log_completed(log)
+            res
           end
         else
-          r = render_component(support, wrapper_html, component_props)
-          support.log_completed("Rendered #{'as empty element that will be mounted on the client side' unless support.ssr?}")
+
+          # Without caching:
+          # just render
+
+          rnd = support.render_svelte(@current_template)
+          r = if rnd[:success]
+                attr = support.tag_attributes(wrapper_html, component_props)
+                content_tag(:div, attr) do
+                  concat(rnd[:head].html_safe)
+                  concat(rnd[:html].html_safe)
+                end
+              else
+                sor_error_tag(support, wrapper_html, component_props, 'server-side-svelte-render-error', 'SVELTE RENDER FAILED')
+              end
+
+          support.log_completed("Rendered#{rnd[:fallback] ? ' (Fallback!)' : ''} #{'as empty element that will be mounted on the client side' unless support.ssr?}")
           r
         end
 
@@ -83,38 +107,6 @@ module SvelteOnRails
 
     private
 
-    def render_component(support, html_options, component_props)
-
-      caller_loc = Proc.new do
-        v_path = @current_template.identifier
-        caller_locations.find { |loc| loc.to_s.include?(v_path) }.to_s.match(/^[\s\S]+(:[0-9]+(?=:in))/).to_s
-      end
-
-      ssr_result = if SvelteOnRails::SsrServer.instance.alive?
-                     SvelteOnRails::SsrServer.instance.render(
-                       support.component_paths,
-                       support.cached_props,
-                       support.debug?,
-                       caller_loc
-                     )
-                   else
-                     SvelteOnRails::Lib::FallbackRenderer.render(support.component_paths, support.cached_props, support.debug?)
-                   end
-
-      if ssr_result[:success]
-        support.set_request_metrics(:rendered)
-        attr = support.tag_attributes(html_options, component_props)
-        content_tag(:div, attr) do
-          concat(ssr_result[:head].html_safe)
-          concat(ssr_result[:html].html_safe)
-        end
-      else
-        support.instance_variable_set(:@skip_caching, true)
-        sor_error_tag(support, html_options, component_props, 'server-side-svelte-render-error', 'SVELTE RENDER FAILED')
-      end
-
-    end
-
     def render_empty_tag(support, html_options, component_props)
 
       support.set_request_metrics(:empty)

data/lib/tasks/svelte_on_rails_tasks.rake

@@ -3,7 +3,53 @@ namespace :svelte_on_rails do
   task :precompile do
     SvelteOnRails::Configuration.instance.vite_build
   end
-end
 
+  desc "check ssr requirements and status"
+  task :check do
+
+    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 = SvelteOnRails::SsrServer.instance(dry_run_ppid: ppid)
+    socket_path = server.socket_path
+
+    puts '=' * 80
+    puts "Svelte on Rails SSR Server"
+    puts '=' * 80
+    puts
+    puts 'Node'
+    puts label('Node bin') + server.node_bin
+    puts label('Node version') + configs.node_version_test
+    puts label('SSR Server bin') + server.ssr_server_bin_path.to_s
+    puts label('SSR Server version') + configs.npm_package_version_test.to_s
+    puts
+    puts 'Rails instance'
+    if !server.ssr_server_ppid_file.exist?
+      puts label('Process.ppid') + "#{server.ssr_server_ppid_file} not found, rails seems not to run"
+    else
+      puts label('Process.ppid') + ppid
+      puts label('Socket') + socket_path
+      puts label('Server uptime')
+    end
+    puts
+    puts '=' * 80
+    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}"
+    end
+    puts
+    puts 'Command for check the server instance:'
+    puts "  • curl --unix-socket #{socket_path} http://localhost"
+
+  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"]

metadata

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