@adonisjs/core 7.0.1 → 7.1.1

package/build/commands/env/add.js

@@ -1,34 +1,91 @@
-import stringHelpers from "../../src/helpers/string.js";
-import { f as BaseCommand, l as flags, o as args } from "../../main-MBAMnmJb.js";
-import { t as __decorate } from "../../decorate-DmrZA614.js";
+import "../../chunk-Do49iUES.js";
+import { t as stringHelpers } from "../../string-8_8He-HH.js";
+import { f as BaseCommand, l as flags, o as args } from "../../main-CRnMnrH7.js";
+import { t as __decorate } from "../../decorate-B9Uz0anB.js";
+//#region commands/env/add.ts
 const ALLOWED_TYPES = [
 	"string",
 	"boolean",
 	"number",
 	"enum"
 ];
+/**
+* Command to add a new environment variable to the application.
+* Updates .env, .env.example, and start/env.ts files with the new variable,
+* including appropriate validation schema based on the variable type.
+*
+* @example
+* ```
+* ace env:add
+* ace env:add DATABASE_URL postgres://localhost:5432/mydb
+* ace env:add API_KEY secret --type=string
+* ace env:add PORT 3333 --type=number
+* ace env:add DEBUG true --type=boolean
+* ace env:add LOG_LEVEL info --type=enum --enum-values=debug,info,warn,error
+* ```
+*/
 var EnvAdd = class extends BaseCommand {
+	/**
+	* The command name
+	*/
 	static commandName = "env:add";
-	static description = "Add a new environment variable";
+	/**
+	* The command description
+	*/
+	static description = "Add a new environment variable to .env, .env.example, and its validation rule to start/env.ts";
+	/**
+	* Command options configuration.
+	* Allows unknown flags to be passed through.
+	*/
 	static options = { allowUnknownFlags: true };
+	/**
+	* Validate that the provided type is one of the allowed types.
+	*
+	* @returns True if the type is valid, false otherwise
+	*/
 	#isTypeFlagValid() {
 		return ALLOWED_TYPES.includes(this.type);
 	}
+	/**
+	* Execute the command to add a new environment variable.
+	* Prompts for missing values, validates inputs, and updates all relevant files.
+	*/
 	async run() {
+		/**
+		* Prompt for missing name
+		*/
 		if (!this.name) this.name = await this.prompt.ask("Enter the variable name", {
 			validate: (value) => !!value,
 			format: (value) => stringHelpers.snakeCase(value).toUpperCase()
 		});
+		/**
+		* Prompt for missing value
+		*/
 		if (!this.value) this.value = await this.prompt.ask("Enter the variable value");
+		/**
+		* Prompt for missing type
+		*/
 		if (!this.type) this.type = await this.prompt.choice("Select the variable type", ALLOWED_TYPES);
+		/**
+		* Prompt for missing enum values if the selected env type is `enum`
+		*/
 		if (this.type === "enum" && !this.enumValues) this.enumValues = await this.prompt.ask("Enter the enum values separated by a comma", { result: (value) => value.split(",").map((one) => one.trim()) });
+		/**
+		* Validate inputs
+		*/
 		if (!this.#isTypeFlagValid()) {
 			this.logger.error(`Invalid type "${this.type}". Must be one of ${ALLOWED_TYPES.join(", ")}`);
 			return;
 		}
+		/**
+		* Add the environment variable to the `.env` and `.env.example` files
+		*/
 		const codemods = await this.createCodemods();
 		const transformedName = stringHelpers.snakeCase(this.name).toUpperCase();
 		await codemods.defineEnvVariables({ [transformedName]: this.value }, { omitFromExample: [transformedName] });
+		/**
+		* Add the environment variable to the `start/env.ts` file
+		*/
 		const validation = {
 			string: "Env.schema.string()",
 			number: "Env.schema.number()",
@@ -53,4 +110,5 @@ __decorate([flags.array({
 	default: [""],
 	required: false
 })], EnvAdd.prototype, "enumValues", void 0);
+//#endregion
 export { EnvAdd as default };

package/build/commands/generate_key.js

@@ -1,10 +1,29 @@
-import { f as BaseCommand, l as flags } from "../main-MBAMnmJb.js";
-import { t as __decorate } from "../decorate-DmrZA614.js";
+import "../chunk-Do49iUES.js";
+import { f as BaseCommand, l as flags } from "../main-CRnMnrH7.js";
+import { t as __decorate } from "../decorate-B9Uz0anB.js";
 import string from "@poppinss/utils/string";
 import { EnvEditor } from "@adonisjs/env/editor";
+//#region commands/generate_key.ts
+/**
+* The generate key command is used to generate the app key
+* and write it inside the .env file.
+*
+* @example
+* ```
+* ace generate:key
+* ace generate:key --show
+* ace generate:key --force
+* ```
+*/
 var GenerateKey = class extends BaseCommand {
+	/**
+	* The command name
+	*/
 	static commandName = "generate:key";
-	static description = "Generate a cryptographically secure random application key";
+	/**
+	* The command description
+	*/
+	static description = "Generate a cryptographically secure APP_KEY and write it to the .env file. Use --show to print without writing";
 	async run() {
 		let writeToFile = process.env.NODE_ENV !== "production";
 		if (this.force) writeToFile = true;
@@ -20,4 +39,5 @@ var GenerateKey = class extends BaseCommand {
 };
 __decorate([flags.boolean({ description: "Display the key on the terminal, instead of writing it to .env file" })], GenerateKey.prototype, "show", void 0);
 __decorate([flags.boolean({ description: "Force update .env file in production environment" })], GenerateKey.prototype, "force", void 0);
+//#endregion
 export { GenerateKey as default };

package/build/commands/inspect_rcfile.js

@@ -1,7 +1,30 @@
-import { f as BaseCommand } from "../main-MBAMnmJb.js";
+import "../chunk-Do49iUES.js";
+import { f as BaseCommand } from "../main-CRnMnrH7.js";
+//#region commands/inspect_rcfile.ts
+/**
+* Command to inspect and display the AdonisJS RC file contents with default values.
+* The RC file contains configuration for providers, preloads, commands, and other
+* application settings. This command formats and displays the contents in a readable JSON format.
+*
+* @example
+* ```
+* ace inspect:rcfile
+* ```
+*/
 var InspectRCFile = class extends BaseCommand {
+	/**
+	* The command name
+	*/
 	static commandName = "inspect:rcfile";
-	static description = "Inspect the RC file with its default values";
+	/**
+	* The command description
+	*/
+	static description = "Display the resolved adonisrc.ts configuration as JSON, including providers, preloads, commands, and meta files";
+	/**
+	* Execute the command to display RC file contents.
+	* Transforms provider, preload, and command entries to display their file paths
+	* as strings and formats the output as readable JSON.
+	*/
 	async run() {
 		const { raw, providers, preloads, commands, ...rest } = this.app.rcFile;
 		this.logger.log(JSON.stringify({
@@ -24,4 +47,5 @@ var InspectRCFile = class extends BaseCommand {
 		}, null, 2));
 	}
 };
+//#endregion
 export { InspectRCFile as default };

package/build/commands/list/routes.d.ts

@@ -49,6 +49,11 @@ export default class ListRoutes extends BaseCommand {
      * Output routes as a CLI table format
      */
     table: boolean;
+    /**
+     * Output routes as JSONL (one JSON object per line), optimized for
+     * machine consumption by AI agents and CLI tools
+     */
+    jsonl: boolean;
     /**
      * Execute the command to list application routes.
      * Creates a formatter with the specified filters and outputs routes

package/build/commands/list/routes.js

@@ -1,13 +1,55 @@
-import { f as BaseCommand, l as flags, o as args, s as cliHelpers } from "../../main-MBAMnmJb.js";
-import { t as __decorate } from "../../decorate-DmrZA614.js";
+import "../../chunk-Do49iUES.js";
+import { f as BaseCommand, l as flags, o as args, s as cliHelpers } from "../../main-CRnMnrH7.js";
+import { t as __decorate } from "../../decorate-B9Uz0anB.js";
 import stringWidth from "string-width";
 import { middlewareInfo, routeInfo } from "@adonisjs/http-server/helpers";
+//#region src/cli_formatters/routes_list.ts
+/**
+* Routes list formatter is used to format the routes to JSON or an ANSI string
+* with pretty output.
+*
+* The decisions of colors, padding, alignment are all handled by the lists formatter
+*
+* @example
+* const formatter = new RoutesListFormatter(router, ui, {
+*   displayHeadRoutes: false,
+*   maxPrettyPrintWidth: 120
+* }, {
+*   match: 'api',
+*   middleware: ['auth']
+* })
+*
+* const ansiOutput = await formatter.formatAsAnsiList()
+*/
 var RoutesListFormatter = class {
+	/**
+	* Router instance containing all registered routes
+	*/
 	#router;
+	/**
+	* Colors utility for ANSI formatting
+	*/
 	#colors;
+	/**
+	* Table utility for creating formatted tables
+	*/
 	#table;
+	/**
+	* Options for printing routes
+	*/
 	#options;
+	/**
+	* Filters to apply when finding routes
+	*/
 	#filters;
+	/**
+	* Creates a new instance of the routes list formatter
+	*
+	* @param router - Router instance containing routes to format
+	* @param ui - UI primitives for colors and table formatting
+	* @param options - Display options for route formatting
+	* @param filters - Filters to apply when displaying routes
+	*/
 	constructor(router, ui, options, filters) {
 		this.#router = router;
 		this.#colors = ui.colors;
@@ -16,22 +58,56 @@ var RoutesListFormatter = class {
 		this.#options = options;
 		this.#router.commit();
 	}
+	/**
+	* Test if a route clears the applied filters based on middleware, name, pattern, and handler.
+	*
+	* @param route - The serialized route to test against filters
+	*/
 	#isAllowedByFilters(route) {
 		let allowRoute = true;
+		/**
+		* Check if the route is allowed by applying the middleware
+		* filter
+		*/
 		if (this.#filters.middleware) allowRoute = this.#filters.middleware.every((name) => {
 			if (name === "*") return route.middleware.length > 0;
 			return route.middleware.find((middleware) => middleware.name === name);
 		});
+		/**
+		* Check if the route has any or the ignored middleware. If yes, do not
+		* display the route
+		*/
 		if (allowRoute && this.#filters.ignoreMiddleware) allowRoute = this.#filters.ignoreMiddleware.every((name) => {
 			if (name === "*") return route.middleware.length === 0;
 			return !route.middleware.find((middleware) => middleware.name === name);
 		});
+		/**
+		* No more filters to be applied
+		*/
 		if (!this.#filters.match) return allowRoute;
+		/**
+		* Check if the route name has the match keyword
+		*/
 		if (route.name.includes(this.#filters.match)) return true;
+		/**
+		* Check if the route pattern has the match keyword
+		*/
 		if (route.pattern.includes(this.#filters.match)) return true;
+		/**
+		* Check if the route handler has the match keyword
+		*/
 		if (route.handler.type === "controller" ? route.handler.moduleNameOrPath.includes(this.#filters.match) : route.handler.name.includes(this.#filters.match)) return true;
+		/**
+		* Disallow route
+		*/
 		return false;
 	}
+	/**
+	* Serializes routes JSON to an object that can be used for pretty printing.
+	* Converts RouteJSON into a format suitable for display and filtering.
+	*
+	* @param route - The route JSON object to serialize
+	*/
 	async #serializeRoute(route) {
 		let methods = route.methods;
 		if (!this.#options.displayHeadRoutes) methods = methods.filter((method) => method !== "HEAD");
@@ -46,9 +122,19 @@ var RoutesListFormatter = class {
 			middleware: middlewareList.filter((info) => info.type !== "global")
 		};
 	}
+	/**
+	* Formats the route method for the ansi list and table with dim styling.
+	*
+	* @param method - The HTTP method to format (GET, POST, etc.)
+	*/
 	#formatRouteMethod(method) {
 		return this.#colors.dim(method);
 	}
+	/**
+	* Formats route pattern for the ansi list and table with colored parameters and route name.
+	*
+	* @param route - The serialized route containing pattern and name information
+	*/
 	#formatRoutePattern(route) {
 		const pattern = this.#router.parsePattern(route.pattern).map((token) => {
 			if (token.type === 1) return this.#colors.yellow(`:${token.val}`);
@@ -58,15 +144,31 @@ var RoutesListFormatter = class {
 		}).join("/");
 		return `${pattern === "/" ? pattern : `/${pattern}`}${route.name ? ` ${this.#colors.dim(`(${route.name})`)}` : ""} `;
 	}
+	/**
+	* Formats controller name for the ansi list and table with cyan coloring.
+	*
+	* @param route - The serialized route containing handler information
+	*/
 	#formatControllerName(route) {
 		return route.handler.type === "controller" ? ` ${this.#colors.cyan(route.handler.moduleNameOrPath)}.` : "";
 	}
+	/**
+	* Formats action name for the ansi list and table with cyan coloring and arguments.
+	*
+	* @param route - The serialized route containing handler information
+	*/
 	#formatAction(route) {
 		if (route.handler.type === "controller") return `${this.#colors.cyan(route.handler.method)}`;
 		const functionName = ` ${this.#colors.cyan(route.handler.name)}`;
 		if (route.handler.args) return ` ${functionName}${this.#colors.dim(`(${route.handler.args})`)}`;
 		return functionName;
 	}
+	/**
+	* Formats route middleware for the ansi list and table with optional compacting.
+	*
+	* @param route - The serialized route containing middleware information
+	* @param mode - Display mode: 'normal' shows all middleware, 'compact' truncates long lists
+	*/
 	#formatMiddleware(route, mode = "normal") {
 		if (mode === "compact" && route.middleware.length > 3) {
 			const firstMiddleware = route.middleware[0].name;
@@ -76,6 +178,10 @@ var RoutesListFormatter = class {
 		}
 		return this.#colors.dim(`${route.middleware.map((one) => one.name).filter((one) => one).join(", ")}`);
 	}
+	/**
+	* Formatting the domain headling to be in green color with
+	* dots around it
+	*/
 	#formatDomainHeadline(domain) {
 		if (domain !== "root") return cliHelpers.justify([`${this.#colors.dim("..")} ${this.#colors.green(domain)} `], {
 			maxWidth: this.#options.maxPrettyPrintWidth || cliHelpers.TERMINAL_SIZE,
@@ -83,17 +189,29 @@ var RoutesListFormatter = class {
 		})[0];
 		return "";
 	}
+	/**
+	* Justify the ansi list
+	*/
 	#justifyListTables(tables) {
 		return tables.map((table) => {
+			/**
+			* Formatting methods
+			*/
 			const methods = table.rows.map((columns) => columns[0]);
 			const largestMethodsLength = Math.max(...methods.map((method) => stringWidth(method)));
 			const formattedMethods = cliHelpers.justify(methods, { maxWidth: largestMethodsLength });
+			/**
+			* Formatting patterns
+			*/
 			const patterns = table.rows.map((columns) => columns[1]);
 			const largestPatternLength = Math.max(...patterns.map((pattern) => stringWidth(pattern)));
 			const formattedPatterns = cliHelpers.justify(patterns, {
 				maxWidth: largestPatternLength,
 				paddingChar: this.#colors.dim(".")
 			});
+			/**
+			* Formatting middleware to be right aligned
+			*/
 			const middleware = table.rows.map((columns) => columns[3]);
 			const largestMiddlewareLength = Math.max(...middleware.map((one) => stringWidth(one)));
 			const formattedMiddleware = cliHelpers.justify(middleware, {
@@ -101,6 +219,10 @@ var RoutesListFormatter = class {
 				align: "right",
 				paddingChar: " "
 			});
+			/**
+			* Formatting controllers to be right aligned and take all the remaining
+			* space after printing route method, pattern and middleware.
+			*/
 			const controllers = table.rows.map((columns) => columns[2]);
 			const largestControllerLength = (this.#options.maxPrettyPrintWidth || cliHelpers.TERMINAL_SIZE) - (largestPatternLength + largestMethodsLength + largestMiddlewareLength);
 			const formattedControllers = cliHelpers.truncate(cliHelpers.justify(controllers, {
@@ -117,6 +239,55 @@ var RoutesListFormatter = class {
 			};
 		});
 	}
+	/**
+	* Formats middleware info into a compact string representation.
+	* Named middleware with args becomes "name:args", closures use their name as-is.
+	*/
+	#formatMiddlewareAsString(middleware) {
+		if (middleware.type === "named" && middleware.args) return `${middleware.name}:${middleware.args}`;
+		return middleware.name;
+	}
+	/**
+	* Formats routes as JSONL (one JSON object per line). Each line is a
+	* self-contained route object with flattened domain, simplified handler,
+	* and middleware as a string array. Optimized for machine consumption
+	* by AI agents and CLI tools.
+	*/
+	async formatAsJSONL() {
+		const routes = this.#router.toJSON();
+		const domains = Object.keys(routes);
+		const lines = [];
+		for (let domain of domains) for (let route of routes[domain]) {
+			const serializedRoute = await this.#serializeRoute(route);
+			if (!this.#isAllowedByFilters(serializedRoute)) continue;
+			const handler = serializedRoute.handler.type === "controller" ? {
+				type: "controller",
+				module: serializedRoute.handler.moduleNameOrPath,
+				method: serializedRoute.handler.method
+			} : {
+				type: serializedRoute.handler.name === "redirectsToRoute" ? "redirect" : "closure",
+				name: serializedRoute.handler.name,
+				...serializedRoute.handler.args ? { args: serializedRoute.handler.args } : {}
+			};
+			const middleware = serializedRoute.middleware.map((m) => this.#formatMiddlewareAsString(m)).filter((m) => !!m);
+			for (let method of serializedRoute.methods) {
+				const entry = {
+					method,
+					pattern: serializedRoute.pattern,
+					handler
+				};
+				if (serializedRoute.name) entry.name = serializedRoute.name;
+				if (domain !== "root") entry.domain = domain;
+				if (middleware.length > 0) entry.middleware = middleware;
+				lines.push(JSON.stringify(entry));
+			}
+		}
+		return lines;
+	}
+	/**
+	* Formats routes as an array of objects. Routes are grouped by
+	* domain.
+	*/
 	async formatAsJSON() {
 		const routes = this.#router.toJSON();
 		const domains = Object.keys(routes);
@@ -130,6 +301,11 @@ var RoutesListFormatter = class {
 		}
 		return routesJSON;
 	}
+	/**
+	* Format routes to ansi list of tables. Each domain has its own table
+	* with heading and rows. Each row has colums with colors and spacing
+	* around them.
+	*/
 	async formatAsAnsiList() {
 		const routes = this.#router.toJSON();
 		const domains = Object.keys(routes);
@@ -144,6 +320,10 @@ var RoutesListFormatter = class {
 					` ${this.#colors.dim("MIDDLEWARE")}`
 				]]
 			};
+			/**
+			* Computing table rows. Each route+method will have its
+			* own row
+			*/
 			for (let route of routes[domain]) {
 				const serializedRoute = await this.#serializeRoute(route);
 				if (this.#isAllowedByFilters(serializedRoute)) serializedRoute.methods.forEach((method) => {
@@ -159,6 +339,11 @@ var RoutesListFormatter = class {
 		}
 		return this.#justifyListTables(tables);
 	}
+	/**
+	* Format routes to ansi tables. Each domain has its own table
+	* with heading and rows. Each row has colums with colors and spacing
+	* around them.
+	*/
 	async formatAsAnsiTable() {
 		const routes = this.#router.toJSON();
 		const domains = Object.keys(routes);
@@ -179,6 +364,10 @@ var RoutesListFormatter = class {
 					}
 				])
 			};
+			/**
+			* Computing table rows. Each route+method will have its
+			* own row
+			*/
 			for (let route of routes[domain]) {
 				const serializedRoute = await this.#serializeRoute(route);
 				if (this.#isAllowedByFilters(serializedRoute)) serializedRoute.methods.forEach((method) => {
@@ -201,20 +390,68 @@ var RoutesListFormatter = class {
 		return tables;
 	}
 };
+//#endregion
+//#region commands/list/routes.ts
+/**
+* Command to display a list of all registered routes in the application.
+* Supports filtering by keywords, middleware, and output formatting options.
+* Routes can be displayed as a formatted list, table, or JSON.
+*
+* @example
+* ```
+* ace list:routes
+* ace list:routes user
+* ace list:routes --middleware=auth
+* ace list:routes --ignore-middleware=guest
+* ace list:routes --json
+* ace list:routes --table
+* ```
+*/
 var ListRoutes = class extends BaseCommand {
+	/**
+	* The command name
+	*/
 	static commandName = "list:routes";
-	static description = "List application routes. This command will boot the application in the console environment";
+	/**
+	* The command description
+	*/
+	static description = "List all registered routes with their HTTP methods, URL patterns, handlers, and middleware";
+	/**
+	* Command options configuration.
+	* Requires the application to be started so routes are loaded.
+	*/
 	static options = { startApp: true };
+	/**
+	* Execute the command to list application routes.
+	* Creates a formatter with the specified filters and outputs routes
+	* in the requested format (JSON, table, or formatted list).
+	*/
 	async run() {
 		const formatter = new RoutesListFormatter(await this.app.container.make("router"), this.ui, {}, {
 			ignoreMiddleware: this.ignoreMiddleware,
 			middleware: this.middleware,
 			match: this.match
 		});
+		/**
+		* Display as JSONL (one JSON object per line).
+		* Auto-selected when running inside an AI agent and no
+		* explicit format flag is provided.
+		*/
+		if (this.jsonl || !this.json && !this.table && this.app.runningInAIAgent) {
+			const lines = await formatter.formatAsJSONL();
+			for (const line of lines) this.logger.log(line);
+			return;
+		}
+		/**
+		* Display as JSON
+		*/
 		if (this.json) {
 			this.logger.log(JSON.stringify(await formatter.formatAsJSON(), null, 2));
 			return;
 		}
+		/**
+		* Display as a standard table
+		*/
 		if (this.table) {
 			(await formatter.formatAsAnsiTable()).forEach((table) => {
 				this.logger.log("");
@@ -244,4 +481,6 @@ __decorate([flags.array({ description: "View routes that includes all the mentio
 __decorate([flags.array({ description: "View routes that does not include all the mentioned middleware names. Use * to see routes that are using zero middleware" })], ListRoutes.prototype, "ignoreMiddleware", void 0);
 __decorate([flags.boolean({ description: "Get routes list as a JSON string" })], ListRoutes.prototype, "json", void 0);
 __decorate([flags.boolean({ description: "View list of routes as a table" })], ListRoutes.prototype, "table", void 0);
+__decorate([flags.boolean({ description: "Get routes as JSONL, one JSON object per line (optimized for AI agents)" })], ListRoutes.prototype, "jsonl", void 0);
+//#endregion
 export { ListRoutes as default };

package/build/commands/make/command.js

@@ -1,10 +1,38 @@
-import { t as stubsRoot } from "../../main-kn40V-hF.js";
-import { f as BaseCommand, l as flags, o as args } from "../../main-MBAMnmJb.js";
-import { t as __decorate } from "../../decorate-DmrZA614.js";
+import "../../chunk-Do49iUES.js";
+import { t as stubsRoot } from "../../main-CfTiGsiS.js";
+import { f as BaseCommand, l as flags, o as args } from "../../main-CRnMnrH7.js";
+import { t as __decorate } from "../../decorate-B9Uz0anB.js";
+//#region commands/make/command.ts
+/**
+* Command to create a new Ace command class.
+* Ace commands are CLI commands that can be executed via the `ace` binary,
+* allowing you to create custom functionality for your application's command line interface.
+*
+* @example
+* ```
+* ace make:command SendEmails
+* ace make:command ProcessPayments
+* ace make:command GenerateReports
+* ace make:command CleanupFiles
+* ```
+*/
 var MakeCommand = class extends BaseCommand {
+	/**
+	* The command name
+	*/
 	static commandName = "make:command";
-	static description = "Create a new ace command class";
+	/**
+	* The command description
+	*/
+	static description = "Create a new Ace CLI command class in commands/";
+	/**
+	* The stub template file to use for generating the command class
+	*/
 	stubPath = "make/command/main.stub";
+	/**
+	* Execute the command to create a new Ace command class.
+	* Generates the command file with proper CLI command structure.
+	*/
 	async run() {
 		await (await this.createCodemods()).makeUsingStub(stubsRoot, this.stubPath, {
 			flags: this.parsed.flags,
@@ -14,4 +42,5 @@ var MakeCommand = class extends BaseCommand {
 };
 __decorate([args.string({ description: "Name of the command" })], MakeCommand.prototype, "name", void 0);
 __decorate([flags.string({ description: "Use the contents of the given file as the generated output" })], MakeCommand.prototype, "contentsFrom", void 0);
+//#endregion
 export { MakeCommand as default };