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

package/dist/node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js

@@ -0,0 +1,17 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_shebang_regex } from "../../../shebang-regex@3.0.0/node_modules/shebang-regex/index.js";
+//#region ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const shebangRegex = require_shebang_regex();
+	module.exports = (string = "") => {
+		const match = string.match(shebangRegex);
+		if (!match) return null;
+		const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+		const binary = path.split("/").pop();
+		if (binary === "env") return argument;
+		return argument ? `${binary} ${argument}` : binary;
+	};
+}));
+//#endregion
+export default require_shebang_command();
+export { require_shebang_command };

package/dist/node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js

@@ -0,0 +1,8 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = /^#!(.*)/;
+}));
+//#endregion
+export default require_shebang_regex();
+export { require_shebang_regex };

package/dist/node_modules/.pnpm/which@2.0.2/node_modules/which/which.js

@@ -0,0 +1,77 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_isexe } from "../../../isexe@2.0.0/node_modules/isexe/index.js";
+//#region ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const path = __require("path");
+	const COLON = isWindows ? ";" : ":";
+	const isexe = require_isexe();
+	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
+	const getPathInfo = (cmd, opt) => {
+		const colon = opt.colon || COLON;
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || "").split(colon)];
+		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+		if (isWindows) {
+			if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") pathExt.unshift("");
+		}
+		return {
+			pathEnv,
+			pathExt,
+			pathExtExe
+		};
+	};
+	const which = (cmd, opt, cb) => {
+		if (typeof opt === "function") {
+			cb = opt;
+			opt = {};
+		}
+		if (!opt) opt = {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		const step = (i) => new Promise((resolve, reject) => {
+			if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			resolve(subStep(p, i, 0));
+		});
+		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+			if (ii === pathExt.length) return resolve(step(i + 1));
+			const ext = pathExt[ii];
+			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+				if (!er && is) if (opt.all) found.push(p + ext);
+				else return resolve(p + ext);
+				return resolve(subStep(p, i, ii + 1));
+			});
+		});
+		return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+	};
+	const whichSync = (cmd, opt) => {
+		opt = opt || {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		for (let i = 0; i < pathEnv.length; i++) {
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			for (let j = 0; j < pathExt.length; j++) {
+				const cur = p + pathExt[j];
+				try {
+					if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
+					else return cur;
+				} catch (ex) {}
+			}
+		}
+		if (opt.all && found.length) return found;
+		if (opt.nothrow) return null;
+		throw getNotFoundError(cmd);
+	};
+	module.exports = which;
+	which.sync = whichSync;
+}));
+//#endregion
+export default require_which();
+export { require_which };

package/dist/{deno.js → packages/init/deno.js}

@@ -1,4 +1,4 @@
 //#region deno.json
-var version = "2.5.0-dev.2516+42d3ed0b";
+var version = "2.5.0-dev.2541+d39a2437";
 //#endregion
 export { version };

package/dist/scripts/tooling_main.js

@@ -0,0 +1,17 @@
+import process from "node:process";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region ../../scripts/tooling_main.ts
+/** Whether Node.js launched this module as its entry point. */
+function isMain(url) {
+	const entry = process.argv[1];
+	if (entry == null) return false;
+	try {
+		return realpathSync(resolve(entry)) === realpathSync(fileURLToPath(url));
+	} catch {
+		return pathToFileURL(resolve(entry)).href === url;
+	}
+}
+//#endregion
+export { isMain };

package/dist/test/action.d.ts

@@ -0,0 +1,6 @@
+import { TestInitCommand } from "../command.js";
+
+//#region src/test/action.d.ts
+declare function runTestInit(options: TestInitCommand): Promise<boolean>;
+//#endregion
+export { runTestInit as default };

package/dist/test/action.js

@@ -1,12 +1,22 @@
-import { set } from "../utils.js";
 import { checkRequiredDbs } from "./db.js";
 import { fillEmptyOptions } from "./fill.js";
 import runTests from "./run.js";
 import { emptyTestDir, genRunId, genTestDirPrefix, logTestDir } from "./utils.js";
-import { pipe, tap, when } from "@fxts/core";
 //#region src/test/action.ts
-const runTestInit = (options) => pipe(options, set("runId", genRunId), set("testDirPrefix", genTestDirPrefix), tap(emptyTestDir), fillEmptyOptions, tap(checkRequiredDbs), tap(logTestDir), tap(when(isDryRun, runTests(true))), tap(when(isHydRun, runTests(false))));
-const isDryRun = ({ dryRun }) => dryRun;
-const isHydRun = ({ hydRun }) => hydRun;
+async function runTestInit(options) {
+	const runId = genRunId();
+	const data = fillEmptyOptions({
+		...options,
+		runId,
+		testDirPrefix: genTestDirPrefix({ runId })
+	});
+	await emptyTestDir(data);
+	await checkRequiredDbs(data);
+	logTestDir(data);
+	let success = true;
+	if (data.dryRun) success = await runTests(true)(data) && success;
+	if (data.hydRun) success = await runTests(false)(data) && success;
+	return success;
+}
 //#endregion
 export { runTestInit as default };

package/dist/test/cancel.js

@@ -0,0 +1,14 @@
+//#region src/test/cancel.ts
+/** An OS request to stop the initializer matrix after cleaning up its server. */
+var TestInterruptedError = class extends Error {
+	signal;
+	exitCode;
+	constructor(signal) {
+		super(`Initializer tests interrupted by ${signal}`);
+		this.signal = signal;
+		this.name = "TestInterruptedError";
+		this.exitCode = signal === "SIGINT" ? 130 : 143;
+	}
+};
+//#endregion
+export { TestInterruptedError };

package/dist/test/create.js

@@ -2,6 +2,7 @@ import pm_default from "../json/pm.js";
 import { printErrorMessage, printMessage, product } from "../utils.js";
 import { getBuildCommand, kvStores, messageQueues } from "../lib.js";
 import webFrameworks from "../webframeworks/mod.js";
+import { nodeExecutable } from "./node.js";
 import { filter, isEmpty, pipe, toArray } from "@fxts/core";
 import process from "node:process";
 import $ from "@david/dax";
@@ -11,9 +12,10 @@ import { values } from "@optique/core";
 //#region src/test/create.ts
 const BANNED_PMS = ["bun", "yarn"];
 const createTestApp = (testDirPrefix, dry) => async (options) => {
+	if (!dry && options[1] === "deno") await ensureDenoWorkspaceCache();
 	const testDir = join$1(testDirPrefix, ...options);
 	const vals = values(testDir.split(sep).slice(-4));
-	const result = await $`${toArray(genInitCommand(testDir, dry, options))}`.cwd(join$1(import.meta.dirname, "..", "..")).stdin("null").stdout("piped").stderr("piped").noThrow().spawn();
+	const result = await $`${toArray(genInitCommand(testDir, dry, options))}`.cwd(join$1(import.meta.dirname, "..", "..")).env("FEDIFY_TEST_MODE", "true").stdin("null").stdout("piped").stderr("piped").noThrow().spawn();
 	await saveOutputs(testDir, result);
 	if (result.code === 0) {
 		if (!dry && (!await validateDevToolScripts(testDir, options) || !await validateFrameworkBuild(testDir, options))) {
@@ -33,9 +35,8 @@ ${join$1(testDir, "err.txt")}\n`;
 	return "";
 };
 function* genInitCommand(testDir, dry, [webFramework, packageManager, kvStore, messageQueue]) {
-	yield "deno";
-	yield "run";
-	yield "-A";
+	yield nodeExecutable;
+	yield "--experimental-transform-types";
 	yield "src/test/execute.ts";
 	yield "init";
 	yield testDir;
@@ -128,5 +129,9 @@ function filterOptions(options) {
 		messageQueues[mq].packageManagers
 	].every((pms) => pms.includes(pm));
 }
+let denoWorkspaceCache;
+function ensureDenoWorkspaceCache() {
+	return denoWorkspaceCache ??= $`mise run deno:cache`.cwd(join$1(import.meta.dirname, "..", "..", "..", "..")).stdin("null").spawn();
+}
 //#endregion
-export { createTestApp as default, filterOptions, generateTestCases };
+export { createTestApp as default, filterOptions, genInitCommand, generateTestCases };

package/dist/test/lookup.js

@@ -1,12 +1,15 @@
 import { printErrorMessage, printMessage } from "../utils.js";
 import { getDevCommand, kvStores, messageQueues, packageManagers } from "../lib.js";
 import webFrameworks from "../webframeworks/mod.js";
+import { nodeExecutable } from "./node.js";
+import { TestInterruptedError } from "./cancel.js";
 import { replacePortInApp, reservePort } from "./port.js";
 import { STARTUP_TIMEOUT, serverClosure, waitForServer } from "./server.js";
 import { join } from "@fxts/core";
 import $ from "@david/dax";
 import { join as join$1, sep } from "node:path";
 import { values } from "@optique/core";
+import { fileURLToPath } from "node:url";
 //#region src/test/lookup.ts
 const HANDLE = "john";
 const BANNED_LOOKUP_REASONS = {
@@ -22,13 +25,13 @@ const BANNED_LOOKUP_CASES = Object.keys(BANNED_LOOKUP_REASONS).map((key) => key.
 *
 * @param dirs - Array of paths to generated app directories
 */
-async function runServerAndLookupUser(dirs) {
+async function runServerAndLookupUser(dirs, test = testApp) {
 	const valid = dirs.filter(Boolean).filter(isTestable);
 	printSkippedCases(dirs);
 	if (valid.length === 0) printErrorMessage`\nNo directories to lookup test.`;
 	printMessage``;
 	printMessage`Lookup Test start for ${String(valid.length)} app(s)!`;
-	const results = await Array.fromAsync(valid, testApp);
+	const results = await Array.fromAsync(valid, test);
 	const successCount = results.filter(Boolean).length;
 	const failCount = results.length - successCount;
 	printMessage`Lookup Test Results:
@@ -36,6 +39,7 @@ async function runServerAndLookupUser(dirs) {
   Passed: ${String(successCount)}
   Failed: ${String(failCount)}\n\n`;
 	printFailedCases(valid, results);
+	return valid.length > 0 && results.every(Boolean);
 }
 const parseLookupCase = (dir) => dir.split(sep).slice(-4);
 const matchesLookupCasePattern = (target) => (pattern) => pattern.every((value, index) => value === "*" || value === target[index]);
@@ -80,7 +84,10 @@ async function testApp(dir) {
 	const { port, release } = await reservePort();
 	await replacePortInApp(dir, wf, defaultPort, port);
 	printMessage`    Using port ${String(port)}`;
-	const result = await serverClosure(dir, getDevCommand(pm), port, sendLookup, release).catch(() => false);
+	const result = await serverClosure(dir, getDevCommand(pm), port, (port, signal) => sendLookup(port, void 0, signal), release).catch((error) => {
+		if (error instanceof TestInterruptedError) throw error;
+		return false;
+	});
 	printMessage`    Lookup ${result ? "successful" : "failed"} for ${values([
 		wf,
 		pm,
@@ -93,21 +100,24 @@ ${join$1(dir, "err.txt")}\n`;
 	printMessage`\n`;
 	return result;
 }
-async function sendLookup(port) {
+async function sendLookup(port, cliEntry = fileURLToPath(new URL("../../../cli/dist/mod.js", import.meta.url)), signal) {
 	const serverUrl = `http://localhost:${port}`;
 	const lookupTarget = `${serverUrl}/users/${HANDLE}`;
 	printMessage`    Waiting for server to start at ${serverUrl}...`;
-	if (!await waitForServer(serverUrl)) {
+	if (!await waitForServer(serverUrl, 1e4, signal)) {
 		printErrorMessage`Server did not start within ${String(STARTUP_TIMEOUT)}ms`;
 		return false;
 	}
 	printMessage`    Server is ready. Running lookup command...`;
 	try {
-		return (await $`deno task cli lookup ${lookupTarget} -p`.stdin("null").stdout("piped").stderr("piped").noThrow().spawn()).stdout.includes(`id: URL '${lookupTarget}',`);
+		let command = $`${nodeExecutable} ${cliEntry} lookup ${lookupTarget} -p`.stdin("null").stdout("piped").stderr("piped").noThrow();
+		if (signal != null) command = command.signal(signal);
+		const res = await command.spawn();
+		return res.code === 0 && res.stdout.includes(`id: URL '${lookupTarget}',`);
 	} catch (error) {
 		if (error instanceof Error) printErrorMessage`${error.message}`;
 	}
 	return false;
 }
 //#endregion
-export { runServerAndLookupUser as default, isTestable, matchesLookupCasePattern, parseLookupCase };
+export { runServerAndLookupUser as default, isTestable, matchesLookupCasePattern, parseLookupCase, sendLookup };

package/dist/test/mod.d.ts

@@ -1 +1,6 @@
-export { };
+import runTestInit from "./action.js";
+
+//#region src/test/mod.d.ts
+declare function main(action?: typeof runTestInit): Promise<void>;
+//#endregion
+export { main };

package/dist/test/mod.js

@@ -1,15 +1,22 @@
 import { testInitCommand } from "../command.js";
+import { isMain } from "../scripts/tooling_main.js";
+import { TestInterruptedError } from "./cancel.js";
 import runTestInit from "./action.js";
 import process from "node:process";
 import { run } from "@optique/run";
 //#region src/test/mod.ts
-async function main() {
-	await runTestInit(run(testInitCommand, {
+async function main(action = runTestInit) {
+	const result = run(testInitCommand, {
 		programName: "fedify-test-init",
 		help: "both"
-	}));
-	process.exit(0);
+	});
+	try {
+		process.exitCode = await action(result) ? 0 : 1;
+	} catch (error) {
+		if (!(error instanceof TestInterruptedError)) throw error;
+		process.exitCode = error.exitCode;
+	}
 }
-await main();
+if (isMain(import.meta.url)) await main();
 //#endregion
-export {};
+export { main };

package/dist/test/node.js

@@ -0,0 +1,6 @@
+import process from "node:process";
+//#region src/test/node.ts
+/** Select Node.js even when a compatibility test imports the harness in Deno. */
+const nodeExecutable = process.versions.deno != null || process.versions.bun != null ? "node" : process.execPath;
+//#endregion
+export { nodeExecutable };

package/dist/test/port.js

@@ -41,26 +41,47 @@ async function waitForPortRelease(port, timeout = 5e3) {
 	}
 	return false;
 }
-/**
-* Attempt to kill any process listening on the given port using lsof.
-*/
+/** Attempt to stop remaining listeners using the platform's process tools. */
 async function killProcessOnPort(port) {
+	const windows = process.platform === "win32";
 	try {
-		const pids = await new Promise((resolve, reject) => {
-			execFile("lsof", [
+		const output = await new Promise((resolve, reject) => {
+			execFile(windows ? "netstat" : "lsof", windows ? [
+				"-ano",
+				"-p",
+				"tcp"
+			] : [
 				"-t",
 				`-i:${port}`,
 				"-sTCP:LISTEN"
-			], (err, stdout) => {
-				if (err) reject(err);
-				else resolve(stdout);
-			});
+			], {
+				timeout: 1e3,
+				windowsHide: true
+			}, (error, stdout) => error ? reject(error) : resolve(stdout));
 		});
-		for (const pid of pids.trim().split("\n").filter(Boolean)) try {
-			process.kill(parseInt(pid, 10), "SIGKILL");
+		const pids = windows ? parseWindowsListeners(output, port) : output.trim().split(/\s+/).filter((pid) => /^\d+$/.test(pid));
+		for (const pid of new Set(pids)) if (windows) await new Promise((resolve) => {
+			execFile("taskkill", [
+				"/pid",
+				pid,
+				"/t",
+				"/f"
+			], {
+				timeout: 1e3,
+				windowsHide: true
+			}, () => resolve());
+		});
+		else try {
+			process.kill(Number(pid), "SIGKILL");
 		} catch {}
 	} catch {}
 }
+function parseWindowsListeners(output, port) {
+	return output.split(/\r?\n/).flatMap((line) => {
+		const [protocol, localAddress, , state, pid] = line.trim().split(/\s+/);
+		return protocol === "TCP" && localAddress?.endsWith(`:${port}`) && state === "LISTENING" && /^\d+$/.test(pid) ? [pid] : [];
+	});
+}
 /**
 * Reserve a free port by binding to port 0 and letting the OS assign one.
 * The socket is held until the returned `release` function is called,
@@ -123,8 +144,8 @@ async function ensurePortReleased(port) {
 	if (!await waitForPortRelease(port, 5e3)) {
 		printMessage`    Port ${String(port)} still in use—force-killing...`;
 		await killProcessOnPort(port);
-		await waitForPortRelease(port, 3e3);
+		if (!await waitForPortRelease(port, 3e3)) throw new Error(`Port ${port} is still in use after server cleanup`);
 	}
 }
 //#endregion
-export { ensurePortReleased, isPortInUse, killProcessOnPort, replacePortInApp, reservePort, waitForPortRelease };
+export { ensurePortReleased, isPortInUse, killProcessOnPort, parseWindowsListeners, replacePortInApp, reservePort, waitForPortRelease };

package/dist/test/run.js

@@ -1,19 +1,25 @@
 import { printMessage } from "../utils.js";
 import createTestApp, { filterOptions, generateTestCases } from "./create.js";
 import runServerAndLookupUser from "./lookup.js";
-import { always, filter, map, pipe, tap, unless } from "@fxts/core";
-import { join as join$1 } from "node:path";
+import { join } from "node:path";
 import { optionNames } from "@optique/core";
 //#region src/test/run.ts
-const runTests = (dry) => ({ testDirPrefix, dryRun, hydRun, ...options }) => pipe(options, printStartMessage(dry), generateTestCases, filter(filterOptions), map(createTestApp(join$1(testDirPrefix, getMid(dryRun, hydRun, dry)), dry)), Array.fromAsync, unless(always(dry), runServerAndLookupUser));
-const printStartMessage = (dry) => tap(() => printMessage`\n
+const runTests = (dry, runners) => async ({ testDirPrefix, dryRun, hydRun, ...options }) => {
+	printMessage`\n
 Init ${dry ? "Dry" : "Hyd"} Test start!
 Options: ${optionNames([
-	"Web Framework",
-	"Package Manager",
-	"KV Store",
-	"Message Queue"
-])}`);
+		"Web Framework",
+		"Package Manager",
+		"KV Store",
+		"Message Queue"
+	])}`;
+	const create = runners?.create ?? createTestApp(join(testDirPrefix, getMid(dryRun, hydRun, dry)), dry);
+	const dirs = [];
+	for (const testCase of generateTestCases(options)) if (filterOptions(testCase)) dirs.push(await create(testCase));
+	const generated = dirs.length > 0 && dirs.every(Boolean);
+	const lookup = dry ? true : await (runners?.lookup ?? runServerAndLookupUser)(dirs);
+	return generated && lookup;
+};
 const getMid = (dryRun, hydRun, dry) => dryRun === hydRun ? dry ? "dry" : "hyd" : "";
 //#endregion
 export { runTests as default };