svelte-adapter-uws 0.1.0

package/index.js

@@ -0,0 +1,224 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { rollup } from 'rollup';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+
+const files = fileURLToPath(new URL('./files', import.meta.url).href);
+
+// Empty default WebSocket handler - subscribe/unsubscribe is handled
+// by handler.js for ALL messages regardless of user handler.
+const DEFAULT_WS_HANDLER = '// Built-in: subscribe/unsubscribe handled by the runtime\n';
+
+/** @type {import('./index.js').default} */
+export default function (opts = {}) {
+	const { out = 'build', precompress = true, envPrefix = '', healthCheckPath = '/healthz' } = opts;
+
+	// Normalize websocket config: true → {}, false/undefined → null
+	const websocket =
+		opts.websocket === true
+			? {}
+			: opts.websocket || null;
+
+	return {
+		name: 'adapter-uws',
+
+		async adapt(builder) {
+			// Verify uWebSockets.js is installed - it's a native addon from GitHub,
+			// so install failures are common and produce confusing runtime errors
+			try {
+				await import('uWebSockets.js');
+			} catch {
+				throw new Error(
+					'Could not load uWebSockets.js. Make sure it is installed:\n' +
+					'  npm install uNetworking/uWebSockets.js#v20.60.0\n\n' +
+					'It is a native addon installed from GitHub (not npm) and may fail ' +
+					'on some platforms. Check the uWebSockets.js README for details.'
+				);
+			}
+
+			const tmp = builder.getBuildDirectory('adapter-uws');
+
+			builder.rimraf(out);
+			builder.rimraf(tmp);
+			builder.mkdirp(tmp);
+
+			builder.log.minor('Copying assets');
+			builder.writeClient(`${out}/client${builder.config.kit.paths.base}`);
+			builder.writePrerendered(`${out}/prerendered${builder.config.kit.paths.base}`);
+
+			if (precompress) {
+				builder.log.minor('Compressing assets');
+				await Promise.all([
+					builder.compress(`${out}/client`),
+					builder.compress(`${out}/prerendered`)
+				]);
+			}
+
+			builder.log.minor('Building server');
+
+			builder.writeServer(tmp);
+
+			writeFileSync(
+				`${tmp}/manifest.js`,
+				[
+					`export const manifest = ${builder.generateManifest({ relativePath: './' })};`,
+					`export const prerendered = new Set(${JSON.stringify(builder.prerendered.paths)});`,
+					`export const base = ${JSON.stringify(builder.config.kit.paths.base)};`
+				].join('\n\n')
+			);
+
+			// Write the WebSocket handler module
+			if (websocket) {
+				// Resolve the handler: explicit path > auto-discovered > built-in default
+				let handlerFile = websocket.handler;
+
+				if (!handlerFile) {
+					// Auto-discover src/hooks.ws.{js,ts,mjs}
+					const candidates = ['src/hooks.ws.js', 'src/hooks.ws.ts', 'src/hooks.ws.mjs'];
+					for (const candidate of candidates) {
+						if (existsSync(candidate)) {
+							handlerFile = candidate;
+							break;
+						}
+					}
+				}
+
+				if (handlerFile) {
+					const handlerPath = path.resolve(handlerFile).replace(/\\/g, '/');
+					writeFileSync(
+						`${tmp}/ws-handler.js`,
+						`export * from '${handlerPath}';\n`
+					);
+					builder.log.minor(`WebSocket handler: ${handlerFile}`);
+				} else {
+					// No handler found - use built-in default (subscribe/unsubscribe only)
+					writeFileSync(`${tmp}/ws-handler.js`, DEFAULT_WS_HANDLER);
+					builder.log.minor('WebSocket enabled (built-in handler)');
+				}
+			} else {
+				// No WebSocket - empty module
+				writeFileSync(`${tmp}/ws-handler.js`, '// No WebSocket handler configured\n');
+			}
+
+			const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+
+			/** @type {Record<string, string>} */
+			const input = {
+				index: `${tmp}/index.js`,
+				manifest: `${tmp}/manifest.js`,
+				'ws-handler': `${tmp}/ws-handler.js`
+			};
+
+			if (builder.hasServerInstrumentationFile?.()) {
+				input['instrumentation.server'] = `${tmp}/instrumentation.server.js`;
+			}
+
+			// Bundle the Vite output so that deployments only need
+			// their production dependencies. Anything in devDependencies
+			// will get included in the bundled code.
+			const bundle = await rollup({
+				input,
+				external: [
+					// dependencies could have deep exports, so we need a regex
+					...Object.keys(pkg.dependencies || {}).map((d) => new RegExp(`^${d}(\\/.*)?$`)),
+					// uWebSockets.js must stay external - it's a native addon
+					/^uWebSockets\.js$/
+				],
+				plugins: [
+					nodeResolve({
+						preferBuiltins: true,
+						exportConditions: ['node']
+					}),
+					commonjs({ strictRequires: true }),
+					json()
+				]
+			});
+
+			await bundle.write({
+				dir: `${out}/server`,
+				format: 'esm',
+				sourcemap: true,
+				chunkFileNames: 'chunks/[name]-[hash].js'
+			});
+
+			// WebSocket config - serialized as globals for the runtime template
+			const wsPath = websocket?.path ?? '/ws';
+			if (wsPath[0] !== '/') {
+				throw new Error(
+					`websocket.path must start with '/' - got '${wsPath}'. ` +
+					`Use '/${wsPath}' instead.`
+				);
+			}
+			const wsOpts = {
+				maxPayloadLength: websocket?.maxPayloadLength ?? 16 * 1024,
+				idleTimeout: websocket?.idleTimeout ?? 120,
+				maxBackpressure: websocket?.maxBackpressure ?? 1024 * 1024,
+				sendPingsAutomatically: websocket?.sendPingsAutomatically ?? true,
+				compression: websocket?.compression ?? false,
+				allowedOrigins: websocket?.allowedOrigins ?? 'same-origin'
+			};
+
+			builder.copy(files, out, {
+				replace: {
+					ENV: './env.js',
+					HANDLER: './handler.js',
+					MANIFEST: './server/manifest.js',
+					SERVER: './server/index.js',
+					SHIMS: './shims.js',
+					WS_HANDLER: './server/ws-handler.js',
+					ENV_PREFIX: JSON.stringify(envPrefix),
+					PRECOMPRESS: JSON.stringify(precompress),
+					WS_ENABLED: JSON.stringify(!!websocket),
+					WS_PATH: JSON.stringify(wsPath),
+					WS_OPTIONS: JSON.stringify(wsOpts),
+					HEALTH_CHECK_PATH: JSON.stringify(healthCheckPath)
+				}
+			});
+
+			if (builder.hasServerInstrumentationFile?.()) {
+				builder.instrument?.({
+					entrypoint: `${out}/index.js`,
+					instrumentation: `${out}/server/instrumentation.server.js`,
+					module: {
+						exports: ['host', 'port']
+					}
+				});
+			}
+		},
+
+		supports: {
+			read: () => true,
+			instrumentation: () => true
+		},
+
+		emulate() {
+			return {
+				platform() {
+					// Vite plugin sets this when installed
+					if (globalThis.__uws_dev_platform) {
+						return globalThis.__uws_dev_platform;
+					}
+
+					// No Vite plugin - if WebSocket isn't configured, that's fine
+					if (!websocket) return undefined;
+
+					// WebSocket IS configured but plugin is missing - return a
+					// helpful proxy that throws only when actually used
+					const msg =
+						'WebSocket platform not available in dev. Add the Vite plugin to your vite.config.js:\n\n' +
+						"  import uwsDev from 'svelte-adapter-uws/vite';\n" +
+						'  export default { plugins: [sveltekit(), uwsDev()] };';
+					return new Proxy(/** @type {any} */ ({}), {
+						get(_, prop) {
+							if (typeof prop === 'symbol' || prop === 'then') return undefined;
+							throw new Error(msg);
+						}
+					});
+				}
+			};
+		}
+	};
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "svelte-adapter-uws",
+  "version": "0.1.0",
+  "description": "SvelteKit adapter for uWebSockets.js - high-performance C++ HTTP server with built-in WebSocket support",
+  "author": "Kevin Radziszewski",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lanteanio/svelte-adapter-uws.git"
+  },
+  "homepage": "https://github.com/lanteanio/svelte-adapter-uws#readme",
+  "bugs": {
+    "url": "https://github.com/lanteanio/svelte-adapter-uws/issues"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./client": {
+      "types": "./client.d.ts",
+      "default": "./client.js"
+    },
+    "./vite": {
+      "types": "./vite.d.ts",
+      "default": "./vite.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "client.js",
+    "client.d.ts",
+    "vite.js",
+    "vite.d.ts",
+    "files",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@sveltejs/kit": "^2.0.0",
+    "svelte": "^4.0.0 || ^5.0.0",
+    "uWebSockets.js": "uNetworking/uWebSockets.js#v20.60.0",
+    "ws": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "uWebSockets.js": {
+      "optional": true
+    },
+    "ws": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "rollup": "^4.0.0"
+  },
+  "keywords": [
+    "svelte",
+    "sveltekit",
+    "adapter",
+    "uwebsockets",
+    "uws",
+    "performance",
+    "websocket"
+  ],
+  "devDependencies": {
+    "vitest": "^4.0.18"
+  }
+}

package/vite.d.ts

@@ -0,0 +1,48 @@
+import type { Plugin } from 'vite';
+
+export interface UWSDevOptions {
+	/**
+	 * WebSocket endpoint path. Must match the adapter config.
+	 * @default '/ws'
+	 */
+	path?: string;
+
+	/**
+	 * Path to a custom WebSocket handler module (same as adapter's `websocket.handler`).
+	 * Auto-discovers `src/hooks.ws.{js,ts,mjs}` if not specified.
+	 */
+	handler?: string;
+}
+
+/**
+ * Vite plugin for dev mode WebSocket support.
+ *
+ * Add this to your `vite.config.js` so the client store and
+ * `event.platform` work during development:
+ *
+ * ```js
+ * import { sveltekit } from '@sveltejs/kit/vite';
+ * import uwsDev from 'svelte-adapter-uws/vite';
+ *
+ * export default {
+ *   plugins: [sveltekit(), uwsDev()]
+ * };
+ * ```
+ *
+ * That's it - `event.platform` works identically in dev and production:
+ *
+ * ```js
+ * export async function POST({ platform }) {
+ *   platform.publish('todos', 'created', todo);
+ * }
+ * ```
+ *
+ * The adapter's `emulate()` hook provides `event.platform` in dev
+ * using the platform object created by this Vite plugin.
+ */
+export default function uwsDev(options?: UWSDevOptions): Plugin;
+
+declare global {
+	/** Dev-mode platform object - set by the Vite plugin. Same API as production `event.platform`. */
+	var __uws_dev_platform: import('./index.js').Platform | undefined;
+}

package/vite.js

@@ -0,0 +1,310 @@
+import { WebSocketServer } from 'ws';
+import path from 'node:path';
+import { parseCookies } from './files/cookies.js';
+
+/**
+ * Vite plugin that provides WebSocket support during development.
+ *
+ * Uses the same subscribe/unsubscribe/publish protocol as the production
+ * uWS handler, so the client store works identically in dev and prod.
+ *
+ * @param {{ path?: string, handler?: string }} [options]
+ * @returns {import('vite').Plugin}
+ */
+export default function uwsDev(options = {}) {
+	const wsPath = options.path || '/ws';
+
+	/** @type {WebSocketServer} */
+	let wss;
+
+	/** @type {Map<import('ws').WebSocket, Set<string>>} */
+	const subscriptions = new Map();
+
+	/** @type {Set<import('ws').WebSocket>} */
+	const connections = new Set();
+
+	/** @type {Map<import('ws').WebSocket, object>} */
+	const wsWrappers = new Map();
+
+	/** @type {{ upgrade?: Function, open?: Function, message?: Function, close?: Function, drain?: Function }} */
+	let userHandlers = {};
+
+	/**
+	 * Wrap a ws WebSocket to mimic the uWS WebSocket API.
+	 * @param {import('ws').WebSocket} rawWs
+	 * @param {unknown} userData
+	 */
+	function wrapWebSocket(rawWs, userData) {
+		const topics = subscriptions.get(rawWs) || new Set();
+		return {
+			send(message, isBinary = false, _compress = false) {
+				if (rawWs.readyState !== 1) return 0;
+				rawWs.send(typeof message === 'string' ? message : Buffer.from(message));
+				return 1;
+			},
+			close() { rawWs.close(); },
+			end(code, message) { rawWs.close(code, message?.toString()); },
+			subscribe(topic) { topics.add(topic); return true; },
+			unsubscribe(topic) { topics.delete(topic); return true; },
+			publish(topic, message, isBinary = false, _compress = false) {
+				const msg = typeof message === 'string' ? message : Buffer.from(message);
+				for (const [ws, wsTopics] of subscriptions) {
+					if (ws !== rawWs && wsTopics.has(topic) && ws.readyState === 1) {
+						ws.send(msg);
+					}
+				}
+				return true;
+			},
+			isSubscribed(topic) { return topics.has(topic); },
+			getTopics() { return [...topics]; },
+			getUserData() { return userData; },
+			getBufferedAmount() { return rawWs.bufferedAmount || 0; },
+			getRemoteAddress() {
+				return new TextEncoder().encode(rawWs._socket?.remoteAddress || '127.0.0.1').buffer;
+			},
+			getRemoteAddressAsText() {
+				return new TextEncoder().encode(rawWs._socket?.remoteAddress || '127.0.0.1').buffer;
+			},
+			cork(fn) { fn(); }
+		};
+	}
+
+	/**
+	 * Publish to all subscribers of a topic.
+	 * @param {string} topic
+	 * @param {string} event
+	 * @param {unknown} [data]
+	 * @returns {boolean}
+	 */
+	function publish(topic, event, data) {
+		const envelope = JSON.stringify({ topic, event, data });
+		let sent = false;
+		for (const [ws, topics] of subscriptions) {
+			if (topics.has(topic) && ws.readyState === 1) {
+				ws.send(envelope);
+				sent = true;
+			}
+		}
+		return sent;
+	}
+
+	/**
+	 * Send to a single connection.
+	 * @param {object} ws - Wrapped WebSocket
+	 * @param {string} topic
+	 * @param {string} event
+	 * @param {unknown} [data]
+	 * @returns {number}
+	 */
+	function send(ws, topic, event, data) {
+		return ws.send(JSON.stringify({ topic, event, data }), false, false) ?? 1;
+	}
+
+	/**
+	 * Send to connections matching a filter (by userData).
+	 * @param {(userData: any) => boolean} filter
+	 * @param {string} topic
+	 * @param {string} event
+	 * @param {unknown} [data]
+	 * @returns {number}
+	 */
+	function sendTo(filter, topic, event, data) {
+		const envelope = JSON.stringify({ topic, event, data });
+		let count = 0;
+		for (const [, wrapped] of wsWrappers) {
+			if (filter(wrapped.getUserData())) {
+				wrapped.send(envelope);
+				count++;
+			}
+		}
+		return count;
+	}
+
+	// Dev-mode platform - same API shape as production
+	const platform = {
+		publish,
+		send,
+		sendTo,
+		get connections() { return connections.size; },
+		subscribers(topic) {
+			let count = 0;
+			for (const [, topics] of subscriptions) {
+				if (topics.has(topic)) count++;
+			}
+			return count;
+		},
+		topic(name) {
+			return {
+				publish: (/** @type {string} */ event, /** @type {unknown} */ data) => publish(name, event, data),
+				created: (/** @type {unknown} */ data) => publish(name, 'created', data),
+				updated: (/** @type {unknown} */ data) => publish(name, 'updated', data),
+				deleted: (/** @type {unknown} */ data) => publish(name, 'deleted', data),
+				set: (/** @type {number} */ value) => publish(name, 'set', value),
+				increment: (/** @type {number} */ amount = 1) => publish(name, 'increment', amount),
+				decrement: (/** @type {number} */ amount = 1) => publish(name, 'decrement', amount)
+			};
+		}
+	};
+
+	// Expose platform globally so hooks/load functions can access it in dev
+	globalThis.__uws_dev_platform = platform;
+
+	/** @type {Promise<void>} */
+	let handlerReady;
+
+	return {
+		name: 'svelte-adapter-uws',
+		configureServer(server) {
+			wss = new WebSocketServer({ noServer: true });
+			const root = server.config.root;
+
+			// Load user's WebSocket handler - all exports, not just message
+			const handlerPath = options.handler
+				? path.resolve(root, options.handler)
+				: null;
+
+			if (handlerPath) {
+				handlerReady = import(handlerPath).then((mod) => {
+					userHandlers = {
+						upgrade: mod.upgrade,
+						open: mod.open,
+						message: mod.message,
+						close: mod.close,
+						drain: mod.drain,
+						subscribe: mod.subscribe
+					};
+				}).catch((err) => {
+					console.error(`[adapter-uws] Failed to load WebSocket handler '${options.handler}':`, err);
+				});
+			} else {
+				// Auto-discover src/hooks.ws.{js,ts,mjs}
+				const candidates = ['src/hooks.ws.js', 'src/hooks.ws.ts', 'src/hooks.ws.mjs'];
+				handlerReady = (async () => {
+					for (const candidate of candidates) {
+						try {
+							const mod = await import(path.resolve(root, candidate));
+							userHandlers = {
+								upgrade: mod.upgrade,
+								open: mod.open,
+								message: mod.message,
+								close: mod.close,
+								drain: mod.drain,
+								subscribe: mod.subscribe
+							};
+							break;
+						} catch (err) {
+							// File genuinely doesn't exist - try next candidate
+							if (err.code === 'ERR_MODULE_NOT_FOUND' || err.code === 'ENOENT') continue;
+							// File exists but has errors - report and stop searching
+							console.error(`[adapter-uws] Error loading '${candidate}':`, err.message);
+							break;
+						}
+					}
+				})();
+			}
+
+			server.httpServer?.on('upgrade', async (req, socket, head) => {
+				const { pathname } = new URL(req.url || '', 'http://localhost');
+				if (pathname !== wsPath) return;
+
+				// If user has an upgrade handler, run it for auth
+				let userData = {};
+				await handlerReady;
+
+				if (userHandlers.upgrade) {
+					/** @type {Record<string, string>} */
+					const headers = {};
+					for (const [key, value] of Object.entries(req.headers)) {
+						if (typeof value === 'string') headers[key] = value;
+						else if (Array.isArray(value)) headers[key] = value.join(', ');
+					}
+
+					try {
+						const result = await Promise.resolve(
+							userHandlers.upgrade({
+								headers,
+								cookies: parseCookies(headers['cookie']),
+								url: pathname,
+								remoteAddress: req.socket?.remoteAddress || ''
+							})
+						);
+						if (result === false) {
+							socket.write('HTTP/1.1 401 Unauthorized\r\nContent-Type: text/plain\r\n\r\nUnauthorized');
+							socket.destroy();
+							return;
+						}
+						userData = result || {};
+					} catch (err) {
+						console.error('[adapter-uws] WebSocket upgrade error:', err);
+						socket.write('HTTP/1.1 500 Internal Server Error\r\nContent-Type: text/plain\r\n\r\nInternal Server Error');
+						socket.destroy();
+						return;
+					}
+				}
+
+				wss.handleUpgrade(req, socket, head, (ws) => {
+					/** @type {any} */ (ws).__userData = userData;
+					wss.emit('connection', ws, req);
+				});
+			});
+
+			wss.on('connection', (ws) => {
+				connections.add(ws);
+				subscriptions.set(ws, new Set());
+
+				const userData = /** @type {any} */ (ws).__userData || {};
+				const wrapped = wrapWebSocket(ws, userData);
+				wsWrappers.set(ws, wrapped);
+
+				// Call user open handler
+				userHandlers.open?.(wrapped);
+
+				ws.on('message', async (raw, isBinary) => {
+					// Convert to ArrayBuffer (matching uWS interface)
+					const buf = Buffer.isBuffer(raw) ? raw : Buffer.from(/** @type {any} */ (raw));
+					const arrayBuffer = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+
+					// Handle subscribe/unsubscribe from client store
+					if (!isBinary && buf.byteLength < 512) {
+						try {
+							const msg = JSON.parse(buf.toString());
+							if (msg.type === 'subscribe' && typeof msg.topic === 'string') {
+								if (userHandlers.subscribe && userHandlers.subscribe(wrapped, msg.topic) === false) {
+									return;
+								}
+								subscriptions.get(ws)?.add(msg.topic);
+								return;
+							}
+							if (msg.type === 'unsubscribe' && typeof msg.topic === 'string') {
+								subscriptions.get(ws)?.delete(msg.topic);
+								return;
+							}
+						} catch {
+							// Not JSON - fall through to user handler
+						}
+					}
+
+					// Delegate to user handler
+					await handlerReady;
+					if (userHandlers.message) {
+						userHandlers.message(wrapped, arrayBuffer, !!isBinary);
+					}
+				});
+
+				ws.on('close', (code, reason) => {
+					const reasonBuf = reason || Buffer.alloc(0);
+					const reasonAB = reasonBuf.buffer.slice(reasonBuf.byteOffset, reasonBuf.byteOffset + reasonBuf.byteLength);
+					userHandlers.close?.(wrapped, code, reasonAB);
+					connections.delete(ws);
+					subscriptions.delete(ws);
+					wsWrappers.delete(ws);
+				});
+			});
+
+			console.log(`[adapter-uws] Dev WebSocket endpoint at ${wsPath}`);
+			if (wsPath !== '/ws') {
+				console.log(`[adapter-uws] Client must match: connect({ path: '${wsPath}' })`);
+			}
+		}
+	};
+}