@csedl/svelte-on-rails 11.0.4 → 12.0.0

package/bin/svelte-ssr-server.js

@@ -0,0 +1,141 @@
+// app/javascript/ssr/svelte-ssr-server.js
+// Minimal persistent SSR server for SvelteOnRails
+// Listens on Unix socket (preferred) or TCP port fallback
+
+import http from 'node:http';
+import fs   from 'node:fs';
+import path from 'node:path';
+import { render } from 'svelte/server';
+import { readPropsFromStdin } from "../src/ssr/readStdin.js";
+import { loadComponentModule } from "../src/ssr/loadComponent.js";
+
+// Config from ENV or defaults
+const SOCKET_PATH = process.argv[2];
+const PORT = (/^\d+$/.test(SOCKET_PATH) ? SOCKET_PATH : null);
+const LOGFILE = process.env.SVELTE_SSR_SERVER_LOGFILE;
+
+if (!SOCKET_PATH && (process.argv.length <= 2)) {
+    console.error(`Missing first argument: socket path or port number.\nUsage:\nnode svelte-ssr-server.js /path/to/socket.sock\nnode svelte-ssr-server.js 3001`);
+    process.exit(1);
+}
+
+if (LOGFILE) {
+    console.log(`Logging to ${LOGFILE}`);
+} else {
+    console.log(`No log file specified. Logging to stdout.`);
+}
+
+// Clean up old socket file
+if (SOCKET_PATH.startsWith('/') && fs.existsSync(SOCKET_PATH)) {
+    fs.unlinkSync(SOCKET_PATH);
+    logger(`Cleaned old socket: ${SOCKET_PATH}`);
+}
+
+const server = http.createServer(async (req, res) => {
+    // Simple logging
+    logger(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
+
+    // Health check / ping
+    if (req.method === 'GET' && (req.url === '/ping' || req.url === '/health')) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            status: 'alive',
+            uptime: process.uptime(),
+            pid: process.pid,
+            socket: SOCKET_PATH
+        }));
+        return;
+    }
+
+    // SSR render endpoint (stub for now)
+    if (req.method === 'POST' && req.url === '/render') {
+        let request_body = '';
+        req.on('data', chunk => { request_body += chunk; });
+        req.on('end', async () => {
+            try {
+
+                // parsing request-body
+
+                logger(`Parsing request_body...`);
+                const { component, props = {} } = JSON.parse(request_body);
+                const basename = path.basename(component);
+                logger(`Rendering component: ${basename} with props: ${JSON.stringify(props)}`);
+
+                // lad component
+
+                const compiledComponent = await loadComponentModule(component);
+                logger(`Component loaded: «${compiledComponent}»`);
+
+                // render
+
+                const { body, head } = render(compiledComponent, { props });
+                logger(`Component rendered, content: «${body}», head: «${head}»`);
+
+
+
+                // TODO: Replace with real Svelte SSR rendering
+                // Example: const { html, css, head } = YourSvelteComponent.render(props);
+                const dummyHtml = `<div data-component="${component}">Hello from SSR! Props: ${JSON.stringify(props)}</div>`;
+                const dummyCss = '';
+                const dummyHead = '<meta name="ssr-stub" content="placeholder">';
+
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    html: body,
+                    css: dummyCss,
+                    head: head
+                }));
+
+                logger(`Successfully rendered: ${basename}`);
+            } catch (err) {
+                logger(`Render error: ${err}`);
+                logger(`body => «${request_body}»`);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'SSR render failed', details: err.message }));
+            }
+        });
+        return;
+    }
+
+    // Fallback 404
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not found' }));
+});
+
+// LOGGING
+function logger(msg, error = false) {
+    if (error) {
+        console.error(msg);
+    } else {
+        console.log(msg);
+    };
+    if (LOGFILE) {
+        fs.appendFileSync(LOGFILE, `${new Date().toISOString()} ${msg}\n`);
+    }
+}
+
+
+// Start server
+if (PORT) {
+    // TCP mode (e.g. for debugging or non-Unix environments)
+    server.listen(PORT, '127.0.0.1', () => {
+        logger(`Svelte SSR listening on http://127.0.0.1:${PORT}`);
+    });
+} else {
+    // Preferred: Unix socket
+    server.listen(SOCKET_PATH, () => {
+        fs.chmodSync(SOCKET_PATH, 0o600); // restrict access
+        logger(`Svelte SSR listening on unix socket: ${SOCKET_PATH}`);
+    });
+}
+
+// Graceful shutdown
+process.on('SIGINT', () => {
+    logger('Shutting down SSR server...');
+    server.close(() => {
+        if (SOCKET_PATH.startsWith('/') && fs.existsSync(SOCKET_PATH)) {
+            fs.unlinkSync(SOCKET_PATH);
+        }
+        process.exit(0);
+    });
+});

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@csedl/svelte-on-rails",
-  "version": "11.0.4",
+  "version": "12.0.0",
   "description": "Client-side runtime for svelte-on-rails: hydration, SSR build support & Turbo Stream actions",
   "main": "index.js",
   "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "scripts": {
     "build:package": "vite build"
   },
@@ -28,10 +31,7 @@
     "type": "git",
     "url": "https://gitlab.com/sedl/svelte-on-rails"
   },
-  "keywords": [
-    "svelte",
-    "rails"
-  ],
+  "keywords": [ "svelte", "rails"],
   "author": "Christian Sedlmair",
   "license": "LICENSE.md",
   "bugs": {

package/src/ssr/render.js

@@ -7,10 +7,11 @@ const compiledComponentPath = process.argv[2];
 
 
 (async () => {
+    console.log(`${performance.now()}<time>`);
     console.log(`[svelte-on-rails:debug] awaiting load component => «${compiledComponentPath}»`);
     const compiledComponent = await loadComponentModule(compiledComponentPath);
 
-    console.log(`[svelte-on-rails:debug] component read: «${compiledComponent}»`);
+    console.log(`[svelte-on-rails:debug] Component loaded: «${compiledComponent}»`);
 
     const props = await readPropsFromStdin();
     console.log(`[svelte-on-rails:debug] props read: «${JSON.stringify(props)}»`);
@@ -26,7 +27,7 @@ const compiledComponentPath = process.argv[2];
             head: head || '', // Optional: Include <head> content (styles, meta, etc.)
             // Add bodyAttributes or other result props if needed in future
         };
-
+        console.log(`<time>${performance.now()}`);
         console.log('[svelte-on-rails:successful-json-response]' + JSON.stringify(res));
     } catch (error) {
         console.error('[svelte-on-rails:debug] Error rendering component:', error);