@farm.js/cli 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/index.mjs

@@ -8,11 +8,12 @@ import path from "node:path";
 import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "fs";
 import path$1 from "path";
-import { APITypeGenerator, generateEnvTypes, generateFarmI18nTypes, generateRouteTypes, getFarmDocsRouteTypeEntries, getFarmSourceRoots, getIntegrationSchemas, getPresetForDeployTarget, loadConfig, logger, normalizeDeployTarget, resolveConfig, resolveDeployConfig, resolveDeployOutputPath } from "@farm.js/core";
+import { generateFarmTypeArtifacts, getFarmDocsRouteTypeEntries, getFarmSourceRoots, getIntegrationSchemas, getPresetForDeployTarget, loadConfig, logger, normalizeDeployTarget, resolveConfig, resolveDeployConfig, resolveDeployOutputPath } from "@farm.js/core";
 import { spawn, spawnSync } from "node:child_process";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import pc from "picocolors";
 import { Cron } from "croner";
+import { pathToFileURL } from "node:url";
 //#region \0rolldown/runtime.js
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
@@ -59,9 +60,7 @@ async function deployPlatform(platform, root, outputDir, deployConfig, prod) {
 		case "cloudflare":
 			await deployCloudflare(root, outputDir, deployConfig.cloudflare?.projectName || deployConfig.projectName);
 			break;
-		case "netlify":
-			await deployNetlify(root, outputDir, deployConfig.netlify?.site);
-			break;
+		case "netlify": await deployNetlify(root, outputDir, deployConfig.netlify?.site);
 	}
 }
 /**
@@ -282,7 +281,8 @@ async function deployNetlify(root, outputDir, site) {
 	}
 	try {
 		process.chdir(outputDir);
-		execSync(`netlify deploy --prod --dir=.${site ? ` --site=${site}` : ""}`, { stdio: "inherit" });
+		const siteFlag = site ? ` --site=${site}` : "";
+		execSync(`netlify deploy --prod --dir=.${siteFlag}`, { stdio: "inherit" });
 		logger.success("✅ Deployed to Netlify successfully!");
 	} catch (error) {
 		logger.error(`❌ Failed to deploy to Netlify: ${error.message}`);
@@ -765,7 +765,7 @@ function commandExists(command) {
 	return !result.error && result.status === 0;
 }
 function expandTunnelTemplate(template, target, requestedName, requestedHostname) {
-	return template.replaceAll("{url}", shellQuote(target.localUrl)).replaceAll("{port}", shellQuote(String(target.port))).replaceAll("{host}", shellQuote(target.host)).replaceAll("{name}", shellQuote(requestedName)).replaceAll("{hostname}", shellQuote(requestedHostname));
+	return template.split("{url}").join(shellQuote(target.localUrl)).split("{port}").join(shellQuote(String(target.port))).split("{host}").join(shellQuote(target.host)).split("{name}").join(shellQuote(requestedName)).split("{hostname}").join(shellQuote(requestedHostname));
 }
 function shellQuote(value) {
 	return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
@@ -808,31 +808,19 @@ async function generateFarmArtifacts(options = {}) {
 	if (!userConfig && hasSchemaOptions(options)) throw new Error("No Farm config found. Please create farm.config.ts or config.ts.");
 	const resolvedConfig = await resolveConfig({
 		root,
-		...userConfig || {}
+		...userConfig
 	}, "development");
 	const extraRoutes = [...resolvedConfig.openapi?.enabled && resolvedConfig.openapi.route ? [resolvedConfig.openapi.route] : [], ...getFarmDocsRouteTypeEntries(resolvedConfig.docs)];
-	await generateRouteTypes({
+	const typeArtifacts = await generateFarmTypeArtifacts({
 		root: resolvedConfig.root,
 		srcDir: resolvedConfig.srcDir,
+		configPath: options.configPath,
+		layers: resolvedConfig.layers,
 		extraRoutes,
-		suppressLintOnLink: resolvedConfig.suppressLintOnLink
-	});
-	await generateEnvTypes({
-		root: resolvedConfig.root,
-		srcDir: resolvedConfig.srcDir,
-		configPath: options.configPath
+		suppressLintOnLink: resolvedConfig.suppressLintOnLink,
+		i18nConfig: resolvedConfig.i18n
 	});
-	const apiGenerator = new APITypeGenerator(path.join(resolvedConfig.root, resolvedConfig.srcDir, "app"));
-	const apiRoutes = apiGenerator.scanAPIRoutes();
-	const apiTypesPath = path.join(resolvedConfig.root, resolvedConfig.srcDir, "lib", "api.generated.ts");
-	await mkdir(path.dirname(apiTypesPath), { recursive: true });
-	await writeFile(apiTypesPath, apiGenerator.generateAPIRouter(apiRoutes), "utf8");
-	if (resolvedConfig.i18n.enabled) await generateFarmI18nTypes({
-		root: resolvedConfig.root,
-		srcDir: resolvedConfig.srcDir,
-		config: resolvedConfig.i18n
-	});
-	logger.success(`Generated route, API, env${resolvedConfig.i18n.enabled ? ", and i18n" : ""} types (${apiRoutes.length} API route${apiRoutes.length === 1 ? "" : "s"}).`);
+	logger.success(`Generated route, API, env${resolvedConfig.i18n.enabled ? ", and i18n" : ""} types (${typeArtifacts.apiRoutes.length} API route${typeArtifacts.apiRoutes.length === 1 ? "" : "s"}).`);
 	const schemas = getIntegrationSchemas(resolvedConfig.integrations);
 	const schemaEntries = Object.entries(schemas);
 	if (!schemaEntries.length) {
@@ -1071,7 +1059,8 @@ async function writePrismaSchema(schemaPath, models) {
 	const source = await readFile(schemaPath, "utf8");
 	const generated = createPrismaGeneratedBlock(generatePrismaSchema(models));
 	const pattern = new RegExp(`${escapeRegExp(PRISMA_GENERATED_START)}[\\s\\S]*?${escapeRegExp(PRISMA_GENERATED_END)}`, "m");
-	await writeFile(schemaPath, pattern.test(source) ? source.replace(pattern, generated) : `${source.trimEnd()}\n\n${generated}\n`, "utf8");
+	const nextSource = pattern.test(source) ? source.replace(pattern, generated) : `${source.trimEnd()}\n\n${generated}\n`;
+	await writeFile(schemaPath, nextSource, "utf8");
 }
 function generatePrismaSchema(models) {
 	return models.map((model) => renderPrismaModel(model)).join("\n\n");
@@ -1427,7 +1416,7 @@ async function runFarmDoctor(options = {}) {
 	if (!options.offline) try {
 		return createLiveReport(await fetchLiveSnapshot(liveTarget, options), liveTarget, options.now);
 	} catch (error) {
-		liveError = formatError$1(error);
+		liveError = formatError$2(error);
 	}
 	const report = await createProjectReport(root, options);
 	if (!options.offline && hasExplicitLiveTarget(options) && liveError) {
@@ -1587,7 +1576,7 @@ async function createProjectReport(root, options) {
 			status: "fail",
 			code: "CONFIG_INVALID",
 			title: "Farm config could not be resolved",
-			message: formatError$1(error),
+			message: formatError$2(error),
 			action: "Fix the config or environment validation error, then run farm doctor again."
 		});
 	}
@@ -1650,7 +1639,7 @@ function collectPackageCheck(root, checks) {
 			status: "fail",
 			code: "PACKAGE_INVALID",
 			title: "package.json is invalid",
-			message: formatError$1(error),
+			message: formatError$2(error),
 			action: "Fix the package manifest JSON."
 		});
 	}
@@ -1803,7 +1792,7 @@ function finalizeReport(report) {
 function asRecord(value) {
 	return value && typeof value === "object" ? value : {};
 }
-function formatError$1(error) {
+function formatError$2(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function formatCount$1(value, noun) {
@@ -1860,7 +1849,7 @@ async function startFarmCronScheduler(options = {}) {
 				logger.warn(`Cron ${job.name} skipped an overlapping run.`);
 			},
 			catch: (error) => {
-				logger.error(`Cron ${job.name} failed: ${formatError(error)}`);
+				logger.error(`Cron ${job.name} failed: ${formatError$1(error)}`);
 			}
 		}, async () => {
 			logger.info(`Cron ${job.name} -> ${job.path}`);
@@ -1949,7 +1938,7 @@ function formatResponseDetail(body) {
 	const detail = typeof body === "string" ? body : JSON.stringify(body);
 	return detail ? `: ${detail}` : "";
 }
-function formatError(error) {
+function formatError$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
@@ -2066,7 +2055,7 @@ async function createFrameworkMigrationPlan(root, source, options = {}) {
 	};
 	if (source === "next") await planNextMigration(root, packageJson, plan, options);
 	else await planTanStackMigration(root, packageJson, plan, options);
-	addSharedFarmFiles(root, packageJson, plan, source, options);
+	addSharedFarmFiles(root, packageJson, plan, options);
 	return plan;
 }
 async function planNextMigration(root, packageJson, plan, options) {
@@ -2146,32 +2135,22 @@ async function planTanStackMigration(root, packageJson, plan, options) {
 	plan.manual.push("Review loaders, beforeLoad hooks, search params, and Route.use* calls; Farm page modules should move that logic into props, API routes, or server helpers.");
 	if (packageJson) addPackageOperation(root, plan, createMigratedPackageJson(packageJson, "tanstack"));
 }
-function addSharedFarmFiles(root, packageJson, plan, source, options) {
+function addSharedFarmFiles(root, packageJson, plan, options) {
 	if (![
 		"farm.config.ts",
 		"farm.config.mts",
 		"farm.config.js",
 		"farm.config.mjs"
-	].map((file) => path.join(root, file)).find((file) => existsSync(file))) {
-		const output = source === "next" ? `import { defineConfig } from "@farm.js/core";
-
-export default defineConfig({
-  srcDir: "src",
-});
-` : `import { defineConfig } from "@farm.js/core";
+	].map((file) => path.join(root, file)).find((file) => existsSync(file))) plan.operations.push({
+		kind: "write-file",
+		path: path.join(root, "farm.config.ts"),
+		description: "Create farm.config.ts",
+		content: `import { defineConfig } from "@farm.js/core";
 
-export default defineConfig({
-  srcDir: "src",
-});
-`;
-		plan.operations.push({
-			kind: "write-file",
-			path: path.join(root, "farm.config.ts"),
-			description: "Create farm.config.ts",
-			content: output,
-			skipped: false
-		});
-	}
+export default defineConfig({});
+`,
+		skipped: false
+	});
 	const layoutPath = path.join(root, "src", "app", "layout.tsx");
 	if (!existsSync(layoutPath)) plan.operations.push({
 		kind: "write-file",
@@ -2429,6 +2408,201 @@ function toPosix(value) {
 	return value.split(path.sep).join("/");
 }
 //#endregion
-export { addFarmIntegration, buildFarm, createFrameworkMigrationPlan, createGatewaySession, createPreviewGatewayPlan, createPreviewTunnelPlan, createServer, deployFarm, formatFarmCronJobs, formatFarmDoctorReport, forwardGatewayRequest, generateFarmArtifacts, inspectFrameworkMigrations, listFarmCronJobs, listFarmIntegrationProviders, loadFarmCronConfig, migrateFarm, parsePreviewPublicUrl, previewFarm, resolveCloudflareAgentDeployPlan, resolvePreviewTarget, runFarmCronJob, runFarmDoctor, runPreviewGateway, startDevServer, startFarmCronScheduler };
+//#region src/auth.ts
+async function migrateFarmAuth(options = {}) {
+	const root = path.resolve(options.root || process.cwd());
+	const userConfig = await loadConfig(root, options.configPath, "production");
+	if (!userConfig) throw new Error(`No farm.config file was found in ${root}.`);
+	if (!(await resolveConfig({
+		...userConfig,
+		root
+	}, "production")).auth.enabled) throw new Error("Farm Auth is disabled. Add `auth: true` to farm.config.ts first.");
+	const resolveFromApp = createRequire(path.join(root, "package.json"));
+	let modulePath;
+	try {
+		modulePath = resolveFromApp.resolve("@farm.js/auth/internal");
+	} catch {
+		throw new Error("Install @farm.js/auth before running `farm auth migrate`.");
+	}
+	const runtime = await import(
+		/* @vite-ignore */
+		pathToFileURL(modulePath).href
+);
+	logger.info("Applying the Farm Auth database schema...");
+	await runtime.migrateFarmAuth();
+	logger.success("Farm Auth database is ready.");
+}
+//#endregion
+//#region src/upgrade.ts
+const DEPENDENCY_SECTIONS = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"peerDependencies"
+];
+const LOCAL_SPECIFIER_PREFIXES = [
+	"workspace:",
+	"file:",
+	"link:",
+	"portal:",
+	"catalog:"
+];
+async function createFarmUpgradePlan(options) {
+	assertUpgradeChannel(options.channel);
+	const root = path.resolve(options.root || process.cwd());
+	const packageJsonPath = path.join(root, "package.json");
+	let packageJson;
+	try {
+		packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+	} catch (error) {
+		if (!existsSync(packageJsonPath)) throw new Error(`No package.json found at ${packageJsonPath}.`);
+		throw new Error(`Could not read ${packageJsonPath}: ${formatError(error)}`);
+	}
+	const packageManager = options.packageManager || detectFarmPackageManager(root, packageJson.packageManager);
+	const packages = [];
+	const skipped = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const section of DEPENDENCY_SECTIONS) {
+		const dependencies = packageJson[section];
+		if (!dependencies || typeof dependencies !== "object") continue;
+		for (const [name, rawSpecifier] of Object.entries(dependencies)) {
+			if (!name.startsWith("@farm.js/") || seen.has(name)) continue;
+			seen.add(name);
+			const current = typeof rawSpecifier === "string" ? rawSpecifier : String(rawSpecifier);
+			if (isLocalSpecifier(current)) {
+				skipped.push({
+					name,
+					current,
+					section,
+					reason: "local workspace and file dependencies are not published-package upgrades"
+				});
+				continue;
+			}
+			packages.push({
+				name,
+				current,
+				section,
+				target: `${name}@${options.channel}`
+			});
+		}
+	}
+	if (packages.length === 0) {
+		const suffix = skipped.length > 0 ? " The Farm packages in this project use local workspace or file references." : "";
+		throw new Error(`No published @farm.js/* dependencies were found in ${packageJsonPath}.${suffix}`);
+	}
+	packages.sort((left, right) => left.name.localeCompare(right.name));
+	skipped.sort((left, right) => left.name.localeCompare(right.name));
+	return {
+		root,
+		packageJsonPath,
+		packageManager,
+		channel: options.channel,
+		packages,
+		skipped,
+		commands: createUpgradeCommands(root, packageManager, packages)
+	};
+}
+async function upgradeFarm(options) {
+	const plan = await createFarmUpgradePlan(options);
+	if (options.dryRun) return {
+		plan,
+		executed: false
+	};
+	const runCommand = options.runCommand || runFarmUpgradeCommand;
+	for (const command of plan.commands) await runCommand(command);
+	return {
+		plan,
+		executed: true
+	};
+}
+function formatFarmUpgradePlan(plan) {
+	const lines = [
+		`Farm upgrade: ${plan.channel === "latest" ? "latest stable" : "latest beta"}`,
+		`Project: ${plan.root}`,
+		`Package manager: ${plan.packageManager}`,
+		"Packages:"
+	];
+	for (const entry of plan.packages) lines.push(`  ${entry.name} (${entry.section}): ${entry.current} -> ${plan.channel}`);
+	if (plan.skipped.length > 0) {
+		lines.push("Skipped local packages:");
+		for (const entry of plan.skipped) lines.push(`  ${entry.name} (${entry.current})`);
+	}
+	lines.push("Commands:");
+	for (const command of plan.commands) lines.push(`  ${command.command} ${command.args.join(" ")}`);
+	return lines.join("\n");
+}
+function detectFarmPackageManager(root, packageManagerField) {
+	if (typeof packageManagerField === "string") {
+		const name = packageManagerField.split("@", 1)[0];
+		if (isFarmPackageManager(name)) return name;
+	}
+	for (const [packageManager, lockfiles] of [
+		["pnpm", ["pnpm-lock.yaml"]],
+		["yarn", ["yarn.lock"]],
+		["bun", ["bun.lock", "bun.lockb"]],
+		["npm", ["package-lock.json", "npm-shrinkwrap.json"]]
+	]) if (lockfiles.some((lockfile) => existsSync(path.join(root, lockfile)))) return packageManager;
+	return "npm";
+}
+function createUpgradeCommands(root, packageManager, packages) {
+	const command = packageManager === "npm" ? "install" : "add";
+	return DEPENDENCY_SECTIONS.flatMap((section) => {
+		const targets = packages.filter((entry) => entry.section === section).map((entry) => entry.target);
+		if (targets.length === 0) return [];
+		return [{
+			command: packageManager,
+			args: [
+				command,
+				...getDependencySectionFlags(packageManager, section),
+				...targets
+			],
+			cwd: root
+		}];
+	});
+}
+function getDependencySectionFlags(packageManager, section) {
+	if (section === "dependencies") return [];
+	if (packageManager === "yarn" || packageManager === "bun") {
+		if (section === "devDependencies") return ["--dev"];
+		if (section === "optionalDependencies") return ["--optional"];
+		return ["--peer"];
+	}
+	if (section === "devDependencies") return ["--save-dev"];
+	if (section === "optionalDependencies") return ["--save-optional"];
+	return ["--save-peer"];
+}
+function runFarmUpgradeCommand(command) {
+	return new Promise((resolve, reject) => {
+		const executable = process.platform === "win32" ? `${command.command}.cmd` : command.command;
+		const child = spawn(executable, command.args, {
+			cwd: command.cwd,
+			env: process.env,
+			stdio: "inherit"
+		});
+		child.on("error", reject);
+		child.on("close", (code, signal) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			const termination = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
+			reject(/* @__PURE__ */ new Error(`${command.command} ${command.args.join(" ")} failed with ${termination}.`));
+		});
+	});
+}
+function isLocalSpecifier(specifier) {
+	return LOCAL_SPECIFIER_PREFIXES.some((prefix) => specifier.startsWith(prefix));
+}
+function isFarmPackageManager(value) {
+	return value === "npm" || value === "pnpm" || value === "yarn" || value === "bun";
+}
+function assertUpgradeChannel(channel) {
+	if (channel !== "latest" && channel !== "beta") throw new Error("Farm upgrade channel must be \"latest\" or \"beta\".");
+}
+function formatError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { addFarmIntegration, buildFarm, createFarmUpgradePlan, createFrameworkMigrationPlan, createGatewaySession, createPreviewGatewayPlan, createPreviewTunnelPlan, createServer, deployFarm, detectFarmPackageManager, formatFarmCronJobs, formatFarmDoctorReport, formatFarmUpgradePlan, forwardGatewayRequest, generateFarmArtifacts, inspectFrameworkMigrations, listFarmCronJobs, listFarmIntegrationProviders, loadFarmCronConfig, migrateFarm, migrateFarmAuth, parsePreviewPublicUrl, previewFarm, resolveCloudflareAgentDeployPlan, resolvePreviewTarget, runFarmCronJob, runFarmDoctor, runPreviewGateway, startDevServer, startFarmCronScheduler, upgradeFarm };
 
 //# sourceMappingURL=index.mjs.map