create

create sert à déclarer une commande CLI. Vous fournissez un nom et une fonction d'exécution, et vous pouvez aussi ajouter des options, des arguments positionnels, ou des sous-commandes.

Exemple

import { SC } from "@duplojs/server-utils";

const helloCommand = SC.create(
	"hello",
	() => {
		console.log("hello");
	},
);

Syntaxe

function create(
  name: string,
  execute: () => void
): Command

function create<
  GenericOptions extends readonly Option[],
  GenericSubjects extends Subjects
>(
  name: string,
  params: CreateCommandParams<GenericOptions, GenericSubjects>,
  execute: (
    params: CreateCommandExecuteParams<GenericOptions, GenericSubjects>
  ) => MaybePromise<void>
): Command

Paramètres

• name (string) : nom de la commande pour le matching et le rendu du help.
• params (CreateCommandParams, optionnel) : configuration de la commande.
• params.description (string, optionnel) : description affichée dans le help.
• params.options (Option[], optionnel) : parseurs d'options.
• params.subjects (Argument[] | Command[], optionnel) : soit une liste d'arguments positionnels construits avec createArgument, soit une liste de sous-commandes.
• execute : handler de commande. Reçoit des options typées et, quand des arguments positionnels sont déclarés, des args typés.

Valeur de retour

• Command : objet de définition de commande destiné à être accroché à un arbre de commandes et exécuté via exec.

Autres exemples

Avancé

import { SC } from "@duplojs/server-utils";
import { DP, type ExpectType } from "@duplojs/utils";

const deployCommand = SC.create(
	"deploy",
	{
		description: "Deploy the current release",
		options: [
			SC.createOption(
				"environment",
				DP.literal(["staging", "prod"]),
				{ required: true },
			),
		],
		subjects: [
			SC.createArgument(
				"version",
				DP.union([
					DP.templateLiteral([
						"v",
						DP.number(),
						".",
						DP.number(),
						".",
						DP.number(),
					]),
					DP.literal("latest"),
				]),
			),
		],
	},
	({ options: { environment }, args: { version } }) => {
		type check = ExpectType<
			typeof version,
			`v${number}.${number}.${number}` | "latest",
			"strict"
		>;
		type checkOption = ExpectType<
			typeof environment,
			"staging" | "prod",
			"strict"
		>;
	},
);

const releaseCommand = SC.create(
	"release",
	{
		subjects: [deployCommand],
	},
	() => {
		console.log("select a release sub-command");
	},
);

Voir aussi

• exec - Exécute une commande racine depuis les arguments du process.
• createArgument - Construit un argument positionnel utilisé dans subjects.
• createOption - Construit une option à valeur unique.
• createArrayOption - Construit une option tableau.