feat(plugin-help): throw errors when command not found and let other handlers handle it

Author: so1ve

packages/plugin-friendly-error/test/plugin-friendly-error.test.ts

@@ -1,36 +1,49 @@
 import { TestBaseCli } from "@clerc/test-utils";
-import { beforeAll, describe, expect, it, vi } from "vitest";
+import * as kons from "kons";
+import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { friendlyErrorPlugin } from "../src";
 
+vi.mock("kons", () => ({
+	error: vi.fn(),
+}));
+
 describe("plugin-friendly-error", () => {
-	beforeAll(() => {
-		vi.spyOn(process, "exit").mockImplementation(() => ({}) as never);
+	vi.spyOn(process, "exit").mockImplementation(() => ({}) as never);
+	const spy = vi.spyOn(kons, "error").mockImplementation(() => {});
+	vi.mocked(kons.error).mockImplementation(() => {});
+
+	afterEach(() => {
+		spy.mockClear();
 	});
 
 	it("should catch error", async () => {
-		TestBaseCli()
-			.use(
-				friendlyErrorPlugin({
-					target: (s) => {
-						expect(s).toMatchInlineSnapshot(`"No such command: "foo"."`);
-					},
-				}),
-			)
-			.parse(["foo"]);
+		await TestBaseCli().use(friendlyErrorPlugin()).parse(["foo"]);
+
+		expect(spy.mock.calls).toMatchInlineSnapshot(`
+			[
+			  [
+			    "No such command: "foo".",
+			  ],
+			]
+		`);
 	});
 
-	it("should catch async error", () => {
-		TestBaseCli()
-			.use(
-				friendlyErrorPlugin({
-					target: (s) => expect(s).toMatchInlineSnapshot(`"foo error"`),
-				}),
-			)
+	it("should catch async error", async () => {
+		await TestBaseCli()
+			.use(friendlyErrorPlugin())
 			.command("foo", "foo command")
 			.on("foo", async () => {
 				throw new Error("foo error");
 			})
 			.parse(["foo"]);
+
+		expect(spy.mock.calls).toMatchInlineSnapshot(`
+			[
+			  [
+			    "foo error",
+			  ],
+			]
+		`);
 	});
 });

packages/plugin-help/package.json

@@ -53,7 +53,8 @@
 	"devDependencies": {
 		"@clerc/core": "workspace:*",
 		"@clerc/parser": "workspace:*",
-		"@clerc/utils": "workspace:*"
+		"@clerc/utils": "workspace:*",
+		"kons": "^0.7.1"
 	},
 	"peerDependencies": {
 		"@clerc/core": "*"

packages/plugin-help/src/index.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from "@clerc/core";
-import { definePlugin, resolveCommand } from "@clerc/core";
+import { NoSuchCommandError, definePlugin, resolveCommand } from "@clerc/core";
 import { isTruthy } from "@clerc/utils";
 
 import { defaultFormatters } from "./formatters";
@@ -155,9 +155,7 @@ export const helpPlugin = ({
 							[command] = resolveCommand(cli._commands, commandName);
 
 							if (!command) {
-								console.error(`Command "${commandName.join(" ")}" not found.`);
-
-								return;
+								throw new NoSuchCommandError(commandName.join(" "));
 							}
 						}
 
@@ -183,16 +181,22 @@ export const helpPlugin = ({
 			}
 
 			cli.interceptor({
-				enforce: "pre",
+				enforce: "post",
 				handler: async (ctx, next) => {
 					if (ctx.flags.help) {
+						const command = ctx.command;
+						// If no command resolved, but parameters are present, just let the next interceptor handle it
+						if (!command && ctx.rawParsed.parameters.length > 0) {
+							await next();
+						}
+
 						const renderer = new HelpRenderer(
 							mergedFormatters,
 							cli,
 							cli._globalFlags,
-							ctx.command,
-							ctx.command ? ctx.command.help?.notes : effectiveNotes,
-							ctx.command ? ctx.command.help?.examples : effectiveExamples,
+							command,
+							command ? command.help?.notes : effectiveNotes,
+							command ? command.help?.examples : effectiveExamples,
 							groups,
 						);
 						printHelp(renderer.render());

packages/plugin-help/test/__snapshots__/plugin-help.test.ts.snap

@@ -279,3 +279,11 @@ exports[`plugin-help > should use [] as placeholder when root command exists 1`]
   ],
 ]
 `;
+
+exports[`plugin-help > should work with friendly-error 1`] = `
+[
+  [
+    "No such command: "not-exist".",
+  ],
+]
+`;

packages/plugin-help/test/plugin-help.test.ts

@@ -1,10 +1,24 @@
 import { TestBaseCli, getConsoleMock } from "@clerc/test-utils";
-import { afterAll, afterEach, describe, expect, it } from "vitest";
+import { NoSuchCommandError, friendlyErrorPlugin } from "clerc";
+import * as kons from "kons";
+import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
 import { mockConsole } from "vitest-console";
 
 import { helpPlugin } from "../src";
 
+vi.mock("kons", () => ({
+	error: vi.fn(),
+}));
+
 describe("plugin-help", () => {
+	vi.spyOn(process, "exit").mockImplementation(() => ({}) as never);
+	const spy = vi.spyOn(kons, "error").mockImplementation(() => {});
+	vi.mocked(kons.error).mockImplementation(() => {});
+
+	afterEach(() => {
+		spy.mockClear();
+	});
+
 	const { clearConsole, restoreConsole } = mockConsole({ quiet: true });
 
 	afterEach(clearConsole);
@@ -182,4 +196,25 @@ describe("plugin-help", () => {
 			expect(getConsoleMock("log").mock.calls).toMatchSnapshot();
 		});
 	});
+
+	it("should throw error when command not found", async () => {
+		await expect(async () => {
+			await TestBaseCli().use(helpPlugin()).parse(["not-exist", "--help"]);
+		}).rejects.toThrow(NoSuchCommandError);
+
+		await expect(async () => {
+			await TestBaseCli().use(helpPlugin()).parse(["help", "not-exist"]);
+		}).rejects.toThrow(NoSuchCommandError);
+	});
+
+	it("should work with friendly-error", async () => {
+		expect(async () => {
+			await TestBaseCli()
+				.use(helpPlugin())
+				.use(friendlyErrorPlugin())
+				.parse(["not-exist", "--help"]);
+
+			expect(spy.mock.calls).toMatchSnapshot();
+		}).not.toThrow();
+	});
 });

packages/plugin-not-found/test/plugin-not-found.test.ts

@@ -1,12 +1,10 @@
 import { TestBaseCli } from "@clerc/test-utils";
-import { beforeAll, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 import { notFoundPlugin } from "../src";
 
 describe("plugin-not-found", () => {
-	beforeAll(() => {
-		vi.spyOn(process, "exit").mockImplementation(() => ({}) as never);
-	});
+	vi.spyOn(process, "exit").mockImplementation(() => ({}) as never);
 
 	it("should show commands", async () => {
 		await expect(async () => {