refactor(commands): migrate every command to defineCommand

Platform validation, dynamic delegation, native-add and widget, test, create/install/post-install-cli/help, enforced-parameter, device, self-contained, platform, plugin and hooks, open|*, and the rest. Class-based surfaces the migration left without callers are deprecated rather than removed, since extensions may import them.
NativeScript · edusperoni · Sep 14, 2026 · Sep 14, 2026 · Sep 14, 2026 · Sep 14, 2026
commit e4bf7dad047c414e5e591eb54836ab9c0d713d78
diff --git a/lib/bootstrap.ts b/lib/bootstrap.ts
@@ -207,8 +207,6 @@ injector.require(
 	"vitestExecutionService",
 	"./services/vitest-execution-service",
 );
-injector.requireCommand("dev-test|android", "./commands/test");
-injector.requireCommand("dev-test|ios", "./commands/test");
 injector.requireCommand("test|android", "./commands/test");
 injector.requireCommand("test|ios", "./commands/test");
 injector.requireCommand("test|vision", "./commands/test");

diff --git a/lib/commands/add-platform.ts b/lib/commands/add-platform.ts
@@ -1,73 +1,102 @@
-import { ValidatePlatformCommandBase } from "./command-base";
-import { IProjectData } from "../definitions/project";
 import {
-	IOptions,
-	IPlatformCommandHelper,
-	IPlatformValidationService,
-} from "../declarations";
-import { IPlatformsDataService } from "../definitions/platform";
-import { ICommandParameter, ICommand } from "../common/definitions/commands";
+	canExecuteCommandBase,
+	injectPlatformCommandServices,
+	IPlatformCommandServices,
+} from "./command-base";
+import { IPlatformCommandHelper } from "../declarations";
 import { IErrors } from "../common/declarations";
-import { injector } from "../common/yok";
+import {
+	CommandContext,
+	CommandOptionsSchema,
+	defineCommand,
+	stringOption,
+} from "../common/define-command";
+import { inject } from "../common/di";
+import { registerCommand } from "../common/services/command-definition-adapter";
+
+const addPlatformCommandOptions = {
+	frameworkPath: stringOption(),
+} satisfies CommandOptionsSchema;
 
-export class AddPlatformCommand
-	extends ValidatePlatformCommandBase
-	implements ICommand
-{
-	public allowedParameters: ICommandParameter[] = [];
+export type AddPlatformCommandContext = CommandContext<
+	typeof addPlatformCommandOptions
+>;
+
+export interface IAddPlatformCommandServices extends IPlatformCommandServices {
+	$errors: IErrors;
+	$platformCommandHelper: IPlatformCommandHelper;
+}
+
+export function setupAddPlatformCommand(): IAddPlatformCommandServices {
+	const services = {
+		...injectPlatformCommandServices(),
+		$errors: inject<IErrors>("errors"),
+		$platformCommandHelper: inject<IPlatformCommandHelper>(
+			"platformCommandHelper",
+		),
+	};
+	services.$projectData.initializeProjectData();
+
+	return services;
+}
 
-	constructor(
-		$options: IOptions,
-		private $platformCommandHelper: IPlatformCommandHelper,
-		$platformValidationService: IPlatformValidationService,
-		$projectData: IProjectData,
-		$platformsDataService: IPlatformsDataService,
-		private $errors: IErrors
-	) {
-		super(
-			$options,
-			$platformsDataService,
-			$platformValidationService,
-			$projectData
+export async function canExecuteAddPlatformCommand(
+	context: AddPlatformCommandContext,
+	services: IAddPlatformCommandServices,
+): Promise<boolean> {
+	const args = context.args;
+	if (!args || args.length === 0) {
+		services.$errors.failWithHelp(
+			"No platform specified. Please specify a platform to add.",
 		);
-		this.$projectData.initializeProjectData();
 	}
 
-	public async execute(args: string[]): Promise<void> {
-		await this.$platformCommandHelper.addPlatforms(
-			args,
-			this.$projectData,
-			this.$options.frameworkPath
+	let canExecute = true;
+	for (const arg of args) {
+		services.$platformValidationService.validatePlatform(
+			arg,
+			services.$projectData,
 		);
-	}
 
-	public async canExecute(args: string[]): Promise<boolean> {
-		if (!args || args.length === 0) {
-			this.$errors.failWithHelp(
-				"No platform specified. Please specify a platform to add."
+		if (
+			!services.$platformValidationService.isPlatformSupportedForOS(
+				arg,
+				services.$projectData,
+			)
+		) {
+			services.$errors.fail(
+				`Applications for platform ${arg} cannot be built on this OS`,
 			);
 		}
 
-		let canExecute = true;
-		for (const arg of args) {
-			this.$platformValidationService.validatePlatform(arg, this.$projectData);
-
-			if (
-				!this.$platformValidationService.isPlatformSupportedForOS(
-					arg,
-					this.$projectData
-				)
-			) {
-				this.$errors.fail(
-					`Applications for platform ${arg} cannot be built on this OS`
-				);
-			}
+		// The assignment overwrites the previous platform's verdict, so only the
+		// last one decides. Kept as it was.
+		canExecute = await canExecuteCommandBase(services, arg);
+	}
 
-			canExecute = await super.canExecuteCommandBase(arg);
-		}
+	return canExecute;
+}
 
-		return canExecute;
-	}
+export async function runAddPlatformCommand(
+	context: AddPlatformCommandContext,
+	services: IAddPlatformCommandServices,
+): Promise<void> {
+	await services.$platformCommandHelper.addPlatforms(
+		context.args,
+		services.$projectData,
+		context.options.frameworkPath,
+	);
 }
 
-injector.registerCommand("platform|add", AddPlatformCommand);
+export const addPlatformCommandDefinition = defineCommand({
+	name: "platform|add",
+	description:
+		"Configures the current project to target the selected platform.",
+	options: addPlatformCommandOptions,
+	arguments: "any",
+	setup: setupAddPlatformCommand,
+	canExecute: canExecuteAddPlatformCommand,
+	run: runAddPlatformCommand,
+});
+
+registerCommand(addPlatformCommandDefinition);
diff --git a/lib/commands/apple-login.ts b/lib/commands/apple-login.ts
@@ -1,49 +1,65 @@
-import { StringCommandParameter } from "../common/command-params";
-import { ICommand, ICommandParameter } from "../common/definitions/commands";
 import { IErrors } from "../common/declarations";
-import { IInjector } from "../common/definitions/yok";
-import { injector } from "../common/yok";
+import { CommandContext, defineCommand } from "../common/define-command";
+import { inject } from "../common/di";
+import { registerCommand } from "../common/services/command-definition-adapter";
 import { IApplePortalSessionService } from "../services/apple-portal/definitions";
 
-export class AppleLogin implements ICommand {
-	public allowedParameters: ICommandParameter[] = [
-		new StringCommandParameter(this.$injector),
-		new StringCommandParameter(this.$injector),
-	];
-
-	constructor(
-		private $applePortalSessionService: IApplePortalSessionService,
-		private $errors: IErrors,
-		private $injector: IInjector,
-		private $logger: ILogger,
-		private $prompter: IPrompter
-	) {}
-
-	public async execute(args: string[]): Promise<void> {
-		let username = args[0];
-		if (!username) {
-			username = await this.$prompter.getString("Apple ID", {
-				allowEmpty: false,
-			});
-		}
-
-		let password = args[1];
-		if (!password) {
-			password = await this.$prompter.getPassword("Apple ID password");
-		}
-
-		const user = await this.$applePortalSessionService.createUserSession({
-			username,
-			password,
+export type AppleLoginCommandContext = CommandContext;
+
+export interface IAppleLoginCommandServices {
+	$applePortalSessionService: IApplePortalSessionService;
+	$errors: IErrors;
+	$logger: ILogger;
+	$prompter: IPrompter;
+}
+
+export function setupAppleLoginCommand(): IAppleLoginCommandServices {
+	return {
+		$applePortalSessionService: inject<IApplePortalSessionService>(
+			"applePortalSessionService",
+		),
+		$errors: inject<IErrors>("errors"),
+		$logger: inject<ILogger>("logger"),
+		$prompter: inject<IPrompter>("prompter"),
+	};
+}
+
+export async function runAppleLoginCommand(
+	context: AppleLoginCommandContext,
+	services: IAppleLoginCommandServices,
+): Promise<void> {
+	let username = context.args[0];
+	if (!username) {
+		username = await services.$prompter.getString("Apple ID", {
+			allowEmpty: false,
 		});
-		if (!user.areCredentialsValid) {
-			this.$errors.fail(
-				`Invalid username and password combination. Used '${username}' as the username.`
-			);
-		}
-
-		const output = Buffer.from(user.userSessionCookie).toString("base64");
-		this.$logger.info(output);
 	}
+
+	let password = context.args[1];
+	if (!password) {
+		password = await services.$prompter.getPassword("Apple ID password");
+	}
+
+	const user = await services.$applePortalSessionService.createUserSession({
+		username,
+		password,
+	});
+	if (!user.areCredentialsValid) {
+		services.$errors.fail(
+			`Invalid username and password combination. Used '${username}' as the username.`,
+		);
+	}
+
+	const output = Buffer.from(user.userSessionCookie).toString("base64");
+	services.$logger.info(output);
 }
-injector.registerCommand("apple-login", AppleLogin);
+
+export const appleLoginCommandDefinition = defineCommand({
+	name: "apple-login",
+	description: "Logs in to an Apple account and prints the session cookie.",
+	arguments: [{ name: "appleId" }, { name: "password" }],
+	setup: setupAppleLoginCommand,
+	run: runAppleLoginCommand,
+});
+
+registerCommand(appleLoginCommandDefinition);