@lingo.dev/compiler 0.1.0

package/build/translation-server/translation-server.cjs

@@ -0,0 +1,547 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_logger = require('./logger.cjs');
+const require_translator_factory = require('../translators/translator-factory.cjs');
+const require_translation_service = require('../translators/translation-service.cjs');
+const require_cache_factory = require('../translators/cache-factory.cjs');
+const require_manager = require('../metadata/manager.cjs');
+const require_ws_events = require('./ws-events.cjs');
+const require_is_valid_locale = require('../utils/is-valid-locale.cjs');
+let http = require("http");
+http = require_rolldown_runtime.__toESM(http);
+let crypto = require("crypto");
+crypto = require_rolldown_runtime.__toESM(crypto);
+let url = require("url");
+let ws = require("ws");
+
+//#region src/translation-server/translation-server.ts
+/**
+* Simple HTTP server for serving translations during development
+*
+* This server:
+* - Finds a free port automatically
+* - Serves translations via:
+*   - GET /translations/:locale - Full dictionary (cached)
+*   - POST /translations/:locale (body: { hashes: string[] }) - Batch translation
+* - Uses the same translation logic as middleware
+* - Can be started/stopped programmatically
+*/
+var TranslationServer = class {
+	server = null;
+	url = void 0;
+	logger;
+	config;
+	configHash;
+	startPort;
+	onReadyCallback;
+	onErrorCallback;
+	translationService = null;
+	metadata = null;
+	connections = /* @__PURE__ */ new Set();
+	wss = null;
+	wsClients = /* @__PURE__ */ new Set();
+	activeTranslations = 0;
+	isBusy = false;
+	busyTimeout = null;
+	BUSY_DEBOUNCE_MS = 500;
+	constructor(options) {
+		this.config = options.config;
+		this.configHash = hashConfig(options.config);
+		this.startPort = options.startPort || 6e4;
+		this.onReadyCallback = options.onReady;
+		this.onErrorCallback = options.onError;
+		this.logger = require_logger.getLogger(this.config);
+	}
+	/**
+	* Start the server and find an available port
+	*/
+	async start() {
+		if (this.server) throw new Error("Server is already running");
+		this.logger.info(`🔧 Initializing translator...`);
+		this.translationService = new require_translation_service.TranslationService(require_translator_factory.createTranslator(this.config, this.logger), require_cache_factory.createCache(this.config), {
+			sourceLocale: this.config.sourceLocale,
+			pluralization: this.config.pluralization
+		}, this.logger);
+		const port = await this.findAvailablePort(this.startPort);
+		return new Promise((resolve, reject) => {
+			this.server = http.default.createServer((req, res) => {
+				this.logger.info(`📥 Received: ${req.method} ${req.url}`);
+				this.handleRequest(req, res).catch((error) => {
+					this.logger.error(`Request handler error:`, error);
+					this.logger.error(error.stack);
+					if (!res.headersSent) {
+						res.writeHead(500, { "Content-Type": "application/json" });
+						res.end(JSON.stringify({ error: "Internal Server Error" }));
+					}
+				});
+			});
+			this.logger.debug(`Starting translation server on port ${port}`);
+			this.server.on("connection", (socket) => {
+				this.connections.add(socket);
+				socket.once("close", () => {
+					this.connections.delete(socket);
+				});
+			});
+			this.server.on("error", (error) => {
+				if (error.code === "EADDRINUSE") reject(/* @__PURE__ */ new Error(`Port ${port} is already in use`));
+				else {
+					this.logger.error(`Translation server error: ${error.message}\n`);
+					this.onErrorCallback?.(error);
+					reject(error);
+				}
+			});
+			this.server.listen(port, "127.0.0.1", () => {
+				this.url = `http://127.0.0.1:${port}`;
+				this.logger.info(`Translation server listening on ${this.url}`);
+				this.initializeWebSocket();
+				this.onReadyCallback?.(port);
+				resolve(port);
+			});
+		});
+	}
+	/**
+	* Initialize WebSocket server for real-time dev widget updates
+	*/
+	initializeWebSocket() {
+		if (!this.server) throw new Error("HTTP server must be started before WebSocket");
+		this.wss = new ws.WebSocketServer({ server: this.server });
+		this.wss.on("connection", (ws$1) => {
+			this.wsClients.add(ws$1);
+			this.logger.debug(`WebSocket client connected. Total clients: ${this.wsClients.size}`);
+			this.sendToClient(ws$1, require_ws_events.createEvent("connected", { serverUrl: this.url }));
+			ws$1.on("close", () => {
+				this.wsClients.delete(ws$1);
+				this.logger.debug(`WebSocket client disconnected. Total clients: ${this.wsClients.size}`);
+			});
+			ws$1.on("error", (error) => {
+				this.logger.error(`WebSocket client error:`, error);
+				this.wsClients.delete(ws$1);
+			});
+		});
+		this.wss.on("error", (error) => {
+			this.logger.error(`WebSocket server error:`, error);
+			this.onErrorCallback?.(error);
+		});
+		this.logger.info(`WebSocket server initialized`);
+	}
+	/**
+	* Send event to a specific WebSocket client
+	*/
+	sendToClient(ws$1, event) {
+		if (ws$1.readyState === ws.WebSocket.OPEN) ws$1.send(JSON.stringify(event));
+	}
+	/**
+	* Broadcast event to all connected WebSocket clients
+	*/
+	broadcast(event) {
+		const message = JSON.stringify(event);
+		for (const client of this.wsClients) if (client.readyState === ws.WebSocket.OPEN) client.send(message);
+	}
+	/**
+	* Stop the server
+	*/
+	async stop() {
+		if (!this.server) {
+			this.logger.debug("Translation server is not running. Nothing to stop.");
+			return;
+		}
+		if (this.busyTimeout) {
+			clearTimeout(this.busyTimeout);
+			this.busyTimeout = null;
+		}
+		for (const client of this.wsClients) client.close();
+		this.wsClients.clear();
+		if (this.wss) {
+			this.wss.close();
+			this.wss = null;
+		}
+		for (const socket of this.connections) socket.destroy();
+		this.connections.clear();
+		return new Promise((resolve, reject) => {
+			this.server.close((error) => {
+				if (error) reject(error);
+				else {
+					this.logger.info(`Translation server stopped`);
+					this.server = null;
+					this.url = void 0;
+					resolve();
+				}
+			});
+		});
+	}
+	/**
+	* Get the current port (null if not running)
+	*/
+	getUrl() {
+		return this.url;
+	}
+	/**
+	* Start a new server or get the URL of an existing one on the preferred port.
+	*
+	* This method optimizes for the common case where a translation server is already
+	* running on port 60000. If that port is taken, it checks if it's our service
+	* by calling the health check endpoint. If it is, we reuse it instead of starting
+	* a new server on a different port.
+	*
+	* @returns URL of the running server (new or existing)
+	*/
+	async startOrGetUrl() {
+		if (this.server && this.url) {
+			this.logger.info(`Using existing server instance at ${this.url}`);
+			return this.url;
+		}
+		const preferredPort = this.startPort;
+		const preferredUrl = `http://127.0.0.1:${preferredPort}`;
+		if (await this.isPortAvailable(preferredPort)) {
+			this.logger.info(`Port ${preferredPort} is available, starting new server...`);
+			await this.start();
+			return this.url;
+		}
+		this.logger.info(`Port ${preferredPort} is in use, checking if it's a translation server...`);
+		if (await this.checkIfTranslationServer(preferredUrl)) {
+			this.logger.info(`✅ Found existing translation server at ${preferredUrl}, reusing it`);
+			this.url = preferredUrl;
+			return preferredUrl;
+		}
+		this.logger.info(`Port ${preferredPort} is in use by another service, finding alternative...`);
+		await this.start();
+		return this.url;
+	}
+	/**
+	* Check if server is running
+	*/
+	isRunning() {
+		return this.server !== null && this.url !== null;
+	}
+	/**
+	* Reload metadata from disk
+	* Useful when metadata has been updated during runtime (e.g., new transformations)
+	*/
+	async reloadMetadata() {
+		try {
+			this.metadata = await require_manager.loadMetadata(require_manager.getMetadataPath(this.config));
+			this.logger.debug(`Reloaded metadata: ${Object.keys(this.metadata.entries).length} entries`);
+		} catch (error) {
+			this.logger.warn("Failed to reload metadata:", error);
+			this.metadata = require_manager.createEmptyMetadata();
+		}
+	}
+	/**
+	* Translate the entire dictionary for a given locale
+	*
+	* This method always reloads metadata from disk before translating to ensure
+	* all entries added during build-time transformations are included.
+	*
+	* This is the recommended method for build-time translation generation.
+	*/
+	async translateAll(locale) {
+		if (!this.translationService) throw new Error("Translation server not initialized");
+		await this.reloadMetadata();
+		if (!this.metadata) throw new Error("Failed to load metadata");
+		const allHashes = Object.keys(this.metadata.entries);
+		this.logger.info(`Translating all ${allHashes.length} entries to ${locale}`);
+		const startTime = Date.now();
+		this.broadcast(require_ws_events.createEvent("batch:start", {
+			locale,
+			total: allHashes.length,
+			hashes: allHashes
+		}));
+		const result = await this.translationService.translate(locale, this.metadata, allHashes);
+		const duration = Date.now() - startTime;
+		this.broadcast(require_ws_events.createEvent("batch:complete", {
+			locale,
+			total: allHashes.length,
+			successful: Object.keys(result.translations).length,
+			failed: result.errors.length,
+			duration
+		}));
+		return result;
+	}
+	/**
+	* Find an available port starting from the given port
+	*/
+	async findAvailablePort(startPort, maxAttempts = 100) {
+		for (let port = startPort; port < startPort + maxAttempts; port++) if (await this.isPortAvailable(port)) return port;
+		throw new Error(`Could not find available port in range ${startPort}-${startPort + maxAttempts}`);
+	}
+	/**
+	* Check if a port is available
+	*/
+	async isPortAvailable(port) {
+		return new Promise((resolve) => {
+			const testServer = http.default.createServer();
+			testServer.once("error", (error) => {
+				if (error.code === "EADDRINUSE") resolve(false);
+				else resolve(false);
+			});
+			testServer.once("listening", () => {
+				testServer.close(() => {
+					resolve(true);
+				});
+			});
+			testServer.listen(port, "127.0.0.1");
+		});
+	}
+	/**
+	* Mark translation activity start - emits busy event if not already busy
+	*/
+	startTranslationActivity() {
+		this.activeTranslations++;
+		if (this.busyTimeout) {
+			clearTimeout(this.busyTimeout);
+			this.busyTimeout = null;
+		}
+		if (!this.isBusy && this.activeTranslations > 0) {
+			this.isBusy = true;
+			this.broadcast(require_ws_events.createEvent("server:busy", { activeTranslations: this.activeTranslations }));
+			this.logger.debug(`[BUSY] Server is now busy (${this.activeTranslations} active)`);
+		}
+	}
+	/**
+	* Mark translation activity end - emits idle event after debounce period
+	*/
+	endTranslationActivity() {
+		this.activeTranslations = Math.max(0, this.activeTranslations - 1);
+		if (this.activeTranslations === 0 && this.isBusy) {
+			if (this.busyTimeout) clearTimeout(this.busyTimeout);
+			this.busyTimeout = setTimeout(() => {
+				if (this.activeTranslations === 0) {
+					this.isBusy = false;
+					this.broadcast(require_ws_events.createEvent("server:idle", {}));
+					this.logger.debug("[IDLE] Server is now idle");
+				}
+			}, this.BUSY_DEBOUNCE_MS);
+		}
+	}
+	/**
+	* Check if a given URL is running our translation server by calling the health endpoint
+	* Also verifies that the config hash matches to ensure compatible configuration
+	*/
+	async checkIfTranslationServer(url$1) {
+		return new Promise((resolve) => {
+			const healthUrl = `${url$1}/health`;
+			const req = http.default.get(healthUrl, { timeout: 2e3 }, (res) => {
+				let data = "";
+				res.on("data", (chunk) => {
+					data += chunk.toString();
+				});
+				res.on("end", () => {
+					try {
+						if (res.statusCode === 200) {
+							const json = JSON.parse(data);
+							if (json.configHash && json.configHash !== this.configHash) {
+								this.logger.warn(`Existing server has different config (hash: ${json.configHash} vs ${this.configHash}), will start new server`);
+								resolve(false);
+								return;
+							}
+							resolve(true);
+							return;
+						}
+						resolve(false);
+					} catch (error) {
+						resolve(false);
+					}
+				});
+			});
+			req.on("error", () => {
+				resolve(false);
+			});
+			req.on("timeout", () => {
+				req.destroy();
+				resolve(false);
+			});
+		});
+	}
+	/**
+	* Handle incoming HTTP request
+	*/
+	async handleRequest(req, res) {
+		this.logger.info(`🔄 Processing: ${req.method} ${req.url}`);
+		try {
+			const url$1 = new url.URL(req.url || "", `http://${req.headers.host}`);
+			this.logger.debug(`${req.method} ${url$1.pathname}`);
+			res.setHeader("Access-Control-Allow-Origin", "*");
+			res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+			res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+			res.setHeader("Access-Control-Expose-Headers", "Content-Type, Cache-Control");
+			if (req.method === "OPTIONS") {
+				res.writeHead(204);
+				res.end();
+				return;
+			}
+			if (url$1.pathname === "/health") {
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					port: this.url,
+					configHash: this.configHash
+				}));
+				return;
+			}
+			const postMatch = url$1.pathname.match(/^\/translations\/([^/]+)$/);
+			if (postMatch && req.method === "POST") {
+				const [, locale] = postMatch;
+				await this.handleBatchTranslationRequest(locale, req, res);
+				return;
+			}
+			const dictMatch = url$1.pathname.match(/^\/translations\/([^/]+)$/);
+			if (dictMatch && req.method === "GET") {
+				const [, locale] = dictMatch;
+				await this.handleDictionaryRequest(locale, res);
+				return;
+			}
+			res.writeHead(404, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({
+				error: "Not Found",
+				message: "Unknown endpoint",
+				availableEndpoints: [
+					"GET /health",
+					"GET /translations/:locale",
+					"POST /translations/:locale (with body: { hashes: string[] })"
+				]
+			}));
+		} catch (error) {
+			this.logger.error("Error handling request:", error);
+			res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({
+				error: "Internal Server Error",
+				message: error instanceof Error ? error.message : "Unknown error"
+			}));
+		}
+	}
+	/**
+	* Handle batch translation request
+	*/
+	async handleBatchTranslationRequest(locale, req, res) {
+		try {
+			const parsedLocale = require_is_valid_locale.parseLocaleOrThrow(locale);
+			let body = "";
+			this.logger.debug("Reading request body...");
+			for await (const chunk of req) {
+				body += chunk.toString();
+				this.logger.debug(`Chunk read, body: ${body}`);
+			}
+			const { hashes } = JSON.parse(body);
+			this.logger.debug(`Parsed hashes: ${hashes.join(",")}`);
+			if (!Array.isArray(hashes)) {
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					error: "Bad Request",
+					message: "Body must contain 'hashes' array"
+				}));
+				return;
+			}
+			if (!this.translationService) throw new Error("Translation service not initialized");
+			await this.reloadMetadata();
+			if (!this.metadata) throw new Error("Failed to load metadata");
+			this.logger.info(`🔄 Translating ${hashes.length} hashes to ${locale}`);
+			this.logger.debug(`🔄 Hashes: ${hashes.join(", ")}`);
+			this.startTranslationActivity();
+			try {
+				const result = await this.translationService.translate(parsedLocale, this.metadata, hashes);
+				res.writeHead(200, {
+					"Content-Type": "application/json",
+					"Cache-Control": "no-cache"
+				});
+				res.end(JSON.stringify({
+					locale,
+					translations: result.translations,
+					errors: result.errors
+				}));
+			} finally {
+				this.endTranslationActivity();
+			}
+		} catch (error) {
+			this.logger.error(`Error getting batch translations for ${locale}:`, error);
+			res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({
+				error: "Translation generation failed",
+				message: error instanceof Error ? error.message : "Unknown error"
+			}));
+		}
+	}
+	/**
+	* Handle request for full translation dictionary
+	*/
+	async handleDictionaryRequest(locale, res) {
+		try {
+			const parsedLocale = require_is_valid_locale.parseLocaleOrThrow(locale);
+			if (!this.translationService) throw new Error("Translation service not initialized");
+			await this.reloadMetadata();
+			if (!this.metadata) throw new Error("Failed to load metadata");
+			this.logger.info(`🌐 Requesting full dictionary for ${locale}`);
+			const allHashes = Object.keys(this.metadata.entries);
+			const result = await this.translationService.translate(parsedLocale, this.metadata, allHashes);
+			res.writeHead(200, {
+				"Content-Type": "application/json",
+				"Cache-Control": "public, max-age=3600"
+			});
+			res.end(JSON.stringify({
+				locale,
+				translations: result.translations,
+				errors: result.errors
+			}));
+		} catch (error) {
+			this.logger.error(`Error getting dictionary for ${locale}:`, error);
+			res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({
+				error: "Translation generation failed",
+				message: error instanceof Error ? error.message : "Unknown error"
+			}));
+		}
+	}
+};
+function stableStringify(value) {
+	const normalize = (v) => {
+		if (v === void 0) return void 0;
+		if (typeof v === "function") return void 0;
+		if (v === null) return null;
+		if (Array.isArray(v)) return v.map(normalize).filter((x) => x !== void 0);
+		if (typeof v === "object") {
+			const out = {};
+			for (const key of Object.keys(v).sort()) {
+				const next = normalize(v[key]);
+				if (next !== void 0) out[key] = next;
+			}
+			return out;
+		}
+		return v;
+	};
+	return JSON.stringify(normalize(value));
+}
+/**
+* Generate a stable hash of a config object
+* Filters out functions and non-serializable values
+* Sorts keys for stability
+*/
+function hashConfig(config) {
+	const serialized = stableStringify(config);
+	return crypto.default.createHash("md5").update(serialized).digest("hex").slice(0, 12);
+}
+/**
+* Create and start a translation server
+*/
+async function startTranslationServer(options) {
+	const server = new TranslationServer(options);
+	await server.start();
+	return server;
+}
+/**
+* Create a translation server and start it or reuse an existing one on the preferred port
+*
+* Since we have little control over the dev server start in next, we can start the translation server only in the loader,
+* and loaders could be started from multiple processes (it seems) or similar we need a way to avoid starting multiple servers.
+* This one will try to start a server on the preferred port (which seems to be an atomic operation), and if it fails,
+* it checks if the server already started is ours and returns its url.
+*
+* @returns Object containing the server instance and its URL
+*/
+async function startOrGetTranslationServer(options) {
+	const server = new TranslationServer(options);
+	return {
+		server,
+		url: await server.startOrGetUrl()
+	};
+}
+
+//#endregion
+exports.startOrGetTranslationServer = startOrGetTranslationServer;
+exports.startTranslationServer = startTranslationServer;