@fedify/init 2.5.0-dev.2516 → 2.5.0-dev.2541

package/dist/test/server.js

@@ -1,32 +1,39 @@
+import { __toESM } from "../_virtual/_rolldown/runtime.js";
 import { printErrorMessage } from "../utils.js";
-import { ensurePortReleased, killProcessOnPort } from "./port.js";
+import { TestInterruptedError } from "./cancel.js";
+import { ensurePortReleased } from "./port.js";
+import { require_cross_spawn } from "../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js";
 import process from "node:process";
 import { createWriteStream } from "node:fs";
 import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { Readable } from "node:stream";
+import { execFile } from "node:child_process";
+import { finished } from "node:stream/promises";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#region src/test/server.ts
+var import_cross_spawn = /* @__PURE__ */ __toESM(require_cross_spawn(), 1);
 const STARTUP_TIMEOUT = 1e4;
-/**
-* Wait for the server to be ready by checking if it responds to requests.
-*/
-async function waitForServer(url, timeout = STARTUP_TIMEOUT) {
+/** Wait for the generated application to respond successfully. */
+async function waitForServer(url, timeout = STARTUP_TIMEOUT, signal) {
 	const startTime = Date.now();
 	while (Date.now() - startTime < timeout) {
+		signal?.throwIfAborted();
 		try {
-			const response = await fetch(url, { signal: AbortSignal.timeout(1e3) });
+			const timeoutSignal = AbortSignal.timeout(1e3);
+			const response = await fetch(url, { signal: signal == null ? timeoutSignal : AbortSignal.any([signal, timeoutSignal]) });
 			const ok = response.ok;
 			await response.body?.cancel();
 			if (ok) return true;
 		} catch {}
-		await new Promise((resolve) => setTimeout(resolve, 500));
+		await setTimeout$1(500, void 0, { signal });
 	}
 	return false;
 }
-async function serverClosure(dir, cmd, defaultPort, callback, releasePort) {
+/** Run a generated application's server and always stop its process tree. */
+async function serverClosure(dir, cmd, defaultPort, callback, releasePort, signal) {
 	await releasePort?.();
-	const devCommand = cmd.split(" ");
-	const child = spawn(devCommand[0], devCommand.slice(1), {
+	signal?.throwIfAborted();
+	const command = typeof cmd === "string" ? cmd.split(" ") : cmd;
+	const child = (0, import_cross_spawn.default)(command[0], [...command.slice(1)], {
 		cwd: dir,
 		env: {
 			...process.env,
@@ -37,121 +44,142 @@ async function serverClosure(dir, cmd, defaultPort, callback, releasePort) {
 			"pipe",
 			"pipe"
 		],
-		detached: true
+		detached: process.platform !== "win32"
 	});
-	child.on("error", () => {});
-	const stdoutWeb = Readable.toWeb(child.stdout);
-	const stderrWeb = Readable.toWeb(child.stderr);
-	const [stdoutForFile, stdoutForPort] = stdoutWeb.tee();
-	const [stderrForFile, stderrForPort] = stderrWeb.tee();
-	const cleanup = new AbortController();
 	const outFile = createWriteStream(join(dir, "out.txt"), { flags: "a" });
 	const errFile = createWriteStream(join(dir, "err.txt"), { flags: "a" });
-	const pipeOutDone = pipeStream(stdoutForFile, outFile, cleanup.signal);
-	const pipeErrDone = pipeStream(stderrForFile, errFile, cleanup.signal);
+	const filesDone = Promise.all([finished(outFile), finished(errFile)]);
+	filesDone.catch(() => {});
+	child.stdout.pipe(outFile, { end: false });
+	child.stderr.pipe(errFile, { end: false });
+	let rejectFailure;
+	const failure = new Promise((_, reject) => rejectFailure = reject);
+	failure.catch(() => {});
+	const closed = new Promise((resolve) => child.once("close", () => resolve()));
+	child.once("error", (error) => rejectFailure(error));
+	child.once("exit", (code, exitSignal) => {
+		rejectFailure(/* @__PURE__ */ new Error(`Server exited (${exitSignal ?? code})`));
+	});
+	outFile.once("error", (error) => rejectFailure(error));
+	errFile.once("error", (error) => rejectFailure(error));
+	const onAbort = () => rejectFailure(signal?.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Server test aborted"));
+	const onInterrupt = () => rejectFailure(new TestInterruptedError("SIGINT"));
+	const onTerminate = () => rejectFailure(new TestInterruptedError("SIGTERM"));
+	signal?.addEventListener("abort", onAbort, { once: true });
+	process.once("SIGINT", onInterrupt);
+	process.once("SIGTERM", onTerminate);
+	if (signal?.aborted) onAbort();
 	let port = defaultPort;
+	const detection = detectPort(child);
+	let operationError;
+	let failed = false;
+	let result;
+	const shutdown = new AbortController();
 	try {
-		port = await determinePort(stdoutForPort, stderrForPort, cleanup.signal).catch((err) => {
-			printErrorMessage`Failed to determine server port: ${err.message}`;
+		port = await Promise.race([detection.result.catch((error) => {
+			printErrorMessage`Failed to determine server port: ${error.message}`;
 			printErrorMessage`Use default port ${String(defaultPort)} for lookup.`;
 			return defaultPort;
-		});
-		return await callback(port);
+		}), failure]);
+		result = await Promise.race([callback(port, shutdown.signal), failure]);
+	} catch (error) {
+		operationError = error;
+		failed = true;
 	} finally {
+		shutdown.abort(/* @__PURE__ */ new Error("Server test finished"));
+		detection.stop();
+		signal?.removeEventListener("abort", onAbort);
+		process.removeListener("SIGINT", onInterrupt);
+		process.removeListener("SIGTERM", onTerminate);
 		try {
-			if (child.pid != null) process.kill(-child.pid, "SIGKILL");
-		} catch {}
+			await stopProcessTree(child, closed);
+		} catch (error) {
+			if (!failed) operationError = error;
+			failed = true;
+			printErrorMessage`Failed to stop server: ${String(error)}`;
+		} finally {
+			child.stdout.destroy();
+			child.stderr.destroy();
+			outFile.end();
+			errFile.end();
+		}
 		try {
-			child.kill("SIGKILL");
-		} catch {}
-		cleanup.abort();
-		await Promise.all([pipeOutDone, pipeErrDone]).catch(() => {});
-		await killProcessOnPort(port);
-		outFile.end();
-		errFile.end();
-		await ensurePortReleased(port);
+			await filesDone;
+			if (child.pid != null) await ensurePortReleased(port);
+		} catch (error) {
+			if (!failed) operationError = error;
+			failed = true;
+			printErrorMessage`Failed to clean up server: ${String(error)}`;
+		}
 	}
+	if (failed) throw operationError;
+	return result;
 }
-function determinePort(stdout, stderr, signal) {
-	return new Promise((resolve, reject) => {
-		const timeout = setTimeout(() => {
-			reject(/* @__PURE__ */ new Error("Timeout: Could not determine port from server output"));
-		}, STARTUP_TIMEOUT);
-		let stdoutData = "";
-		let stderrData = "";
-		let streamsEnded = 0;
-		const portPatterns = [
-			/listening on.*:(\d+)/i,
-			/server.*:(\d+)/i,
-			/port\s*:?\s*(\d+)/i,
-			/https?:\/\/localhost:(\d+)/i,
-			/https?:\/\/0\.0\.0\.0:(\d+)/i,
-			/https?:\/\/127\.0\.0\.1:(\d+)/i,
-			/https?:\/\/[^:]+:(\d+)/i
-		];
-		const checkForPort = (data) => {
-			for (const pattern of portPatterns) {
-				const match = data.match(pattern);
-				if (match && match[1]) {
-					const port = Number.parseInt(match[1], 10);
+function detectPort(child) {
+	let output = "";
+	let timer;
+	let onData;
+	const stop = () => {
+		clearTimeout(timer);
+		child.stdout.removeListener("data", onData);
+		child.stderr.removeListener("data", onData);
+	};
+	return {
+		result: new Promise((resolve, reject) => {
+			timer = setTimeout(() => {
+				stop();
+				reject(/* @__PURE__ */ new Error("Timeout: Could not determine port from server output"));
+			}, STARTUP_TIMEOUT);
+			onData = (chunk) => {
+				output += chunk.toString("utf8");
+				for (const pattern of [
+					/listening on.*:(\d+)/i,
+					/server.*:(\d+)/i,
+					/port\s*:?\s*(\d+)/i,
+					/https?:\/\/[^:]+:(\d+)/i
+				]) {
+					const match = pattern.exec(output);
+					const port = Number(match?.[1]);
 					if (port > 0 && port < 65536) {
-						clearTimeout(timeout);
-						return port;
+						stop();
+						resolve(port);
+						break;
 					}
 				}
-			}
-			return null;
-		};
-		const onStreamEnd = () => {
-			streamsEnded++;
-			if (streamsEnded === 2) {
-				clearTimeout(timeout);
-				reject(/* @__PURE__ */ new Error("Server exited before port could be determined"));
-			}
-		};
-		const readStream = async (stream, onData) => {
-			const reader = stream.getReader();
-			const onAbort = () => void reader.cancel().catch(() => {});
-			signal?.addEventListener("abort", onAbort, { once: true });
-			const decoder = new TextDecoder();
+			};
+			child.stdout.on("data", onData);
+			child.stderr.on("data", onData);
+		}),
+		stop
+	};
+}
+async function stopProcessTree(child, closed) {
+	if (child.pid == null) return;
+	if (process.platform === "win32") await new Promise((resolve) => {
+		execFile("taskkill", [
+			"/pid",
+			String(child.pid),
+			"/t",
+			"/f"
+		], {
+			timeout: 1e3,
+			windowsHide: true
+		}, () => resolve());
+	});
+	else {
+		const kill = (signal) => {
 			try {
-				while (true) {
-					const { done, value } = await reader.read();
-					if (done) break;
-					onData(decoder.decode(value, { stream: true }));
-				}
-			} catch {} finally {
-				signal?.removeEventListener("abort", onAbort);
-				reader.releaseLock();
-				onStreamEnd();
+				process.kill(-child.pid, signal);
+			} catch (error) {
+				if (error.code !== "ESRCH") throw error;
 			}
 		};
-		readStream(stdout, (chunk) => {
-			stdoutData += chunk;
-			const port = checkForPort(stdoutData);
-			if (port) resolve(port);
-		});
-		readStream(stderr, (chunk) => {
-			stderrData += chunk;
-			const port = checkForPort(stderrData);
-			if (port) resolve(port);
-		});
-	});
-}
-async function pipeStream(readable, writable, signal) {
-	const reader = readable.getReader();
-	const onAbort = () => void reader.cancel().catch(() => {});
-	signal?.addEventListener("abort", onAbort, { once: true });
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			writable.write(value);
-		}
-	} catch {} finally {
-		signal?.removeEventListener("abort", onAbort);
-		reader.releaseLock();
+		kill("SIGTERM");
+		await Promise.race([closed, setTimeout$1(1e3)]);
+		kill("SIGKILL");
 	}
+	child.kill("SIGKILL");
+	await Promise.race([closed, setTimeout$1(1e3)]);
 }
 //#endregion
 export { STARTUP_TIMEOUT, serverClosure, waitForServer };

package/dist/types.d.ts

@@ -77,6 +77,8 @@ interface MessageQueueDescription {
   object: string;
   /** Deno unstable feature flags required (e.g., `["kv"]`). */
   denoUnstable?: string[];
+  /** Whether this message queue is deprecated but still selectable. */
+  deprecated?: boolean;
   /** Environment variables required, keyed by name to default value. */
   env?: Record<string, string>;
 }
@@ -99,6 +101,8 @@ interface KvStoreDescription {
   object: string;
   /** Deno unstable feature flags required (e.g., `["kv"]`). */
   denoUnstable?: string[];
+  /** Whether this key-value store is deprecated but still selectable. */
+  deprecated?: boolean;
   /** Environment variables required, keyed by name to default value. */
   env?: Record<string, string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/init",
-  "version": "2.5.0-dev.2516+42d3ed0b",
+  "version": "2.5.0-dev.2541+d39a2437",
   "description": "Project initializer for Fedify",
   "keywords": [
     "fedify",
@@ -57,7 +57,9 @@
     "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^24.12.2",
+    "cross-spawn": "^7.0.6",
     "tsdown": "^0.22.0",
     "typescript": "^6.0.0"
   },
@@ -66,7 +68,6 @@
     "build": "pnpm --filter @fedify/init... run build:self",
     "prepublish": "pnpm build",
     "pretest": "pnpm build",
-    "test": "node --test --experimental-transform-types 'src/**/*.test.ts'",
-    "test-init": "deno task test-init"
+    "test": "node --test --experimental-transform-types 'src/**/*.test.ts'"
   }
 }