@farm.js/cli 0.1.0-beta.4 → 0.1.0-beta.6

package/README.md

@@ -8,4 +8,16 @@ Farm.js is currently in beta.
 npm install @farm.js/cli@beta
 ```
 
+Upgrade every published `@farm.js/*` dependency in an app to one release channel:
+
+```bash
+farm upgrade --latest
+farm upgrade --beta
+farm upgrade --latest --dry-run
+```
+
+`--latest` selects the newest stable release. `--beta` selects the newest beta release. The CLI
+detects npm, pnpm, Yarn, or Bun from the project and leaves `workspace:`, `file:`, and other local
+package references unchanged.
+
 See the [Farm.js repository](https://github.com/farming-labs/farm.js) for documentation, examples, and support.

package/bin/farm.js

@@ -80,6 +80,59 @@ program
     }
   });
 
+const authCommand = program.command("auth").description("Manage Farm-native authentication");
+
+authCommand
+  .command("migrate")
+  .description("Create or update the Farm Auth database schema")
+  .option("-r, --root <root>", "Root directory", process.cwd())
+  .option("-c, --config <config>", "Path to farm config file")
+  .action(async (options) => {
+    try {
+      const { migrateFarmAuth } = require("../dist/index.js");
+      await migrateFarmAuth({
+        root: options.root,
+        configPath: options.config,
+      });
+    } catch (error) {
+      console.error("Failed to migrate Farm Auth:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("upgrade")
+  .description("Upgrade installed Farm.js packages to a stable or beta release")
+  .option("-r, --root <root>", "Project root", process.cwd())
+  .option("--latest", "Upgrade to the latest stable release")
+  .option("--beta", "Upgrade to the latest beta release")
+  .option("--dry-run", "Print the package-manager commands without installing")
+  .action(async (options) => {
+    try {
+      if (options.latest === options.beta) {
+        throw new Error("Choose exactly one release channel: --latest (stable) or --beta.");
+      }
+
+      const { formatFarmUpgradePlan, upgradeFarm } = require("../dist/index.js");
+      const result = await upgradeFarm({
+        root: options.root,
+        channel: options.beta ? "beta" : "latest",
+        dryRun: options.dryRun,
+      });
+      console.log(formatFarmUpgradePlan(result.plan));
+      console.log(
+        result.executed
+          ? `Upgraded ${result.plan.packages.length} Farm package${
+              result.plan.packages.length === 1 ? "" : "s"
+            } to ${result.plan.channel}.`
+          : "Dry run only. No packages were changed.",
+      );
+    } catch (error) {
+      console.error("Failed to upgrade Farm packages:", error);
+      process.exit(1);
+    }
+  });
+
 program
   .command("generate")
   .description("Generate route/API types and integration schema artifacts")

package/dist/index.js

@@ -1428,7 +1428,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) {
@@ -1588,7 +1588,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."
 		});
 	}
@@ -1651,7 +1651,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."
 		});
 	}
@@ -1804,7 +1804,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) {
@@ -1861,7 +1861,7 @@ async function startFarmCronScheduler(options = {}) {
 				_farm_js_core.logger.warn(`Cron ${job.name} skipped an overlapping run.`);
 			},
 			catch: (error) => {
-				_farm_js_core.logger.error(`Cron ${job.name} failed: ${formatError(error)}`);
+				_farm_js_core.logger.error(`Cron ${job.name} failed: ${formatError$1(error)}`);
 			}
 		}, async () => {
 			_farm_js_core.logger.info(`Cron ${job.name} -> ${job.path}`);
@@ -1950,7 +1950,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
@@ -2420,8 +2420,179 @@ function toPosix(value) {
 	return value.split(node_path.default.sep).join("/");
 }
 //#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 = node_path.default.resolve(options.root || process.cwd());
+	const packageJsonPath = node_path.default.join(root, "package.json");
+	let packageJson;
+	try {
+		packageJson = JSON.parse(await (0, node_fs_promises.readFile)(packageJsonPath, "utf8"));
+	} catch (error) {
+		if (!(0, node_fs.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) => (0, node_fs.existsSync)(node_path.default.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 = (0, node_child_process.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
 exports.addFarmIntegration = require_add_integration.addFarmIntegration;
 exports.buildFarm = require_build.buildFarm;
+exports.createFarmUpgradePlan = createFarmUpgradePlan;
 exports.createFrameworkMigrationPlan = createFrameworkMigrationPlan;
 exports.createGatewaySession = createGatewaySession;
 exports.createPreviewGatewayPlan = createPreviewGatewayPlan;
@@ -2433,8 +2604,10 @@ Object.defineProperty(exports, "createServer", {
 	}
 });
 exports.deployFarm = deployFarm;
+exports.detectFarmPackageManager = detectFarmPackageManager;
 exports.formatFarmCronJobs = formatFarmCronJobs;
 exports.formatFarmDoctorReport = formatFarmDoctorReport;
+exports.formatFarmUpgradePlan = formatFarmUpgradePlan;
 exports.forwardGatewayRequest = forwardGatewayRequest;
 exports.generateFarmArtifacts = generateFarmArtifacts;
 exports.inspectFrameworkMigrations = inspectFrameworkMigrations;
@@ -2456,5 +2629,6 @@ Object.defineProperty(exports, "startDevServer", {
 	}
 });
 exports.startFarmCronScheduler = startFarmCronScheduler;
+exports.upgradeFarm = upgradeFarm;
 
 //# sourceMappingURL=index.js.map