@adonisjs/core 7.0.0 → 7.1.0

package/build/providers/edge_provider.js

@@ -1,23 +1,76 @@
-import "../chunk-iKc69rpz.js";
-import { t as main_exports } from "../main-DN2qEEg5.js";
-import { pluginEdgeDumper } from "../modules/dumper/plugins/edge.js";
+import "../chunk-Do49iUES.js";
+import { t as main_exports } from "../main-Ck0GqLx4.js";
+import { t as pluginEdgeDumper } from "../edge-BG5ZYp6Z.js";
 import edge from "edge.js";
+//#region providers/edge_provider.ts
+/**
+* The Edge service provider configures Edge to work within
+* an AdonisJS application environment
+*
+* This provider integrates EdgeJS template engine with AdonisJS by:
+* - Mounting the views directory
+* - Configuring template caching for production
+* - Adding global helpers for route generation
+* - Creating isolated renderer instances for HTTP contexts
+* - Adding render macro to BriskRoute for template rendering
+*
+* @example
+* const provider = new EdgeServiceProvider(app)
+* await provider.boot()
+*/
 var EdgeServiceProvider = class {
+	/**
+	* Edge service provider constructor
+	*
+	* Sets the usingEdgeJS flag to true to indicate EdgeJS is being used.
+	*
+	* @param app - The application service instance
+	*/
 	constructor(app) {
 		this.app = app;
 		this.app.usingEdgeJS = true;
 	}
+	/**
+	* Bridge AdonisJS and Edge
+	*
+	* Configures EdgeJS integration by:
+	* - Setting up template mounting and caching
+	* - Defining global helpers (route, signedRoute, app, config)
+	* - Adding view getter to HttpContext for isolated rendering
+	* - Adding render macro to BriskRoute
+	* - Registering dumper plugin
+	*
+	* @example
+	* await provider.boot()
+	* // Now edge templates can use {{ route('home') }} helper
+	*/
 	async boot() {
 		const app = this.app;
 		const qs = new main_exports.Qs(app.config.get("app.http.qs", {}));
 		const router = await this.app.container.make("router");
 		const dumper = await this.app.container.make("dumper");
+		/**
+		* Resolves configuration values for Edge templates
+		*
+		* Provides access to application configuration within templates.
+		* Includes a 'has' method to check for config key existence.
+		*
+		* @param key - The configuration key to retrieve
+		* @param defaultValue - Optional default value if key doesn't exist
+		*/
 		function edgeConfigResolver(key, defaultValue) {
 			return app.config.get(key, defaultValue);
 		}
 		edgeConfigResolver.has = function(key) {
 			return app.config.has(key);
 		};
+		/**
+		* Generates client-side route definitions for frontend use
+		*
+		* Transforms router definitions into a serializable format that
+		* can be used in client-side JavaScript for route generation.
+		* Only includes named routes.
+		*/
 		function clientRoutes() {
 			const routes = router.toJSON();
 			return Object.keys(routes).reduce((result, domain) => {
@@ -35,8 +88,18 @@ var EdgeServiceProvider = class {
 				return result;
 			}, {});
 		}
+		/**
+		* Mount the default disk
+		*/
 		edge.mount(app.viewsPath());
+		/**
+		* Cache templates in production
+		*/
 		edge.configure({ cache: app.inProduction });
+		/**
+		* Define Edge global helpers
+		* @deprecated
+		*/
 		edge.global("route", function(...args) {
 			return router.makeUrl(...args);
 		});
@@ -51,19 +114,35 @@ var EdgeServiceProvider = class {
 		edge.global("routesJSON", function() {
 			return JSON.stringify(clientRoutes());
 		});
+		/**
+		* Route helpers
+		*/
 		edge.global("urlFor", function(...args) {
 			return router.urlBuilder.urlFor(...args);
 		});
 		edge.global("signedUrlFor", function(...args) {
 			return router.urlBuilder.signedUrlFor(...args);
 		});
+		/**
+		* Sharing qs parser with templates
+		*/
 		edge.global("qs", qs);
 		edge.global("formAttributes", function(route, params, options) {
 			const matchingRoute = router.findOrFail(route);
+			/**
+			* Normalize method and keep a reference to the original method
+			*/
 			options = options ?? {};
 			let method = matchingRoute.methods[0].toUpperCase();
 			const original = method;
+			/**
+			* In case of HEAD, we must use the GET method
+			*/
 			if (method === "HEAD") method = "GET";
+			/**
+			* If method if not GET and POST, then use the querystring _method
+			* to and force update the method to "POST"
+			*/
 			if (method !== "GET" && method !== "POST") {
 				method = "POST";
 				options = {
@@ -80,9 +159,16 @@ var EdgeServiceProvider = class {
 				method
 			};
 		});
+		/**
+		* Creating a isolated instance of edge renderer
+		*/
 		main_exports.HttpContext.getter("view", function() {
 			return edge.createRenderer().share({ request: this.request });
 		}, true);
+		/**
+		* Adding brisk route to render templates without an
+		* explicit handler
+		*/
 		main_exports.BriskRoute.macro("render", function(template, data) {
 			function rendersTemplate({ view }) {
 				return view.render(template, data);
@@ -96,4 +182,5 @@ var EdgeServiceProvider = class {
 		edge.use(pluginEdgeDumper(dumper));
 	}
 };
+//#endregion
 export { EdgeServiceProvider as default };

package/build/providers/hash_provider.js

@@ -1,29 +1,84 @@
-import "../chunk-iKc69rpz.js";
-import "../debug-CGQmxzGt.js";
-import { t as configProvider } from "../config_provider-FIAUgvae.js";
-import { t as main_exports } from "../main-DkNgvceD.js";
+import "../chunk-Do49iUES.js";
+import "../debug-DWofTfIX.js";
+import { t as configProvider } from "../config_provider-Do9af1ze.js";
+import { t as main_exports } from "../main-B50zECAi.js";
 import { RuntimeException } from "@poppinss/utils/exception";
+//#region providers/hash_provider.ts
+/**
+* Registers the passwords hasher with the container
+*
+* This provider sets up password hashing functionality by:
+* - Registering the HashManager with configuration from config/hash.ts
+* - Providing a Hash class that uses the default hasher
+* - Supporting multiple hashing drivers (bcrypt, argon2, etc.)
+*
+* @example
+* const provider = new HashServiceProvider(app)
+* provider.register()
+* const hash = await app.container.make('hash')
+*/
 var HashServiceProvider = class {
+	/**
+	* Hash service provider constructor
+	*
+	* @param app - The application service instance
+	*/
 	constructor(app) {
 		this.app = app;
 	}
+	/**
+	* Registering the hash class to resolve an instance with the
+	* default hasher.
+	*
+	* Creates a singleton binding for the Hash class that resolves
+	* the default hasher from the hash manager.
+	*
+	* @example
+	* const hash = await container.make(Hash)
+	* const hashed = await hash.make('password')
+	*/
 	registerHash() {
 		this.app.container.singleton(main_exports.Hash, async (resolver) => {
 			return (await resolver.make("hash")).use();
 		});
 	}
+	/**
+	* Registers the hash manager with the container
+	*
+	* Creates a singleton binding for 'hash' that instantiates
+	* the HashManager with configuration from config/hash.ts file.
+	* Throws an error if the configuration is invalid.
+	*
+	* @example
+	* const hashManager = await container.make('hash')
+	* const bcryptHasher = hashManager.use('bcrypt')
+	*/
 	registerHashManager() {
 		this.app.container.singleton("hash", async () => {
 			const hashConfigProvider = this.app.config.get("hash");
+			/**
+			* Resolve config from the provider
+			*/
 			const config = await configProvider.resolve(this.app, hashConfigProvider);
 			if (!config) throw new RuntimeException("Invalid \"config/hash.ts\" file. Make sure you are using the \"defineConfig\" method");
 			const { HashManager } = await import("../modules/hash/main.js");
 			return new HashManager(config);
 		});
 	}
+	/**
+	* Registers bindings
+	*
+	* Called during the application bootstrap phase to register
+	* the hash manager and hash class with the IoC container.
+	*
+	* @example
+	* const provider = new HashServiceProvider(app)
+	* provider.register() // Registers hash services
+	*/
 	register() {
 		this.registerHashManager();
 		this.registerHash();
 	}
 };
+//#endregion
 export { HashServiceProvider as default };

package/build/providers/repl_provider.js

@@ -1,22 +1,83 @@
-import "../chunk-iKc69rpz.js";
-import { t as repl_exports } from "../modules/repl.js";
+import "../chunk-Do49iUES.js";
+import { t as repl_exports } from "../repl-C02Re0Yd.js";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { fsImportAll } from "@poppinss/utils/fs";
+//#region providers/repl_provider.ts
+/**
+* Resolves a container binding and sets it on the REPL
+* context
+*
+* This helper function makes a service from the container and
+* adds it to the REPL context with a notification message.
+*
+* @param app - The application service instance
+* @param repl - The REPL instance to add the binding to
+* @param binding - The container binding key to resolve
+*
+* @example
+* await resolveBindingForRepl(app, repl, 'router')
+* // Now 'router' variable is available in REPL
+*/
 async function resolveBindingForRepl(app, repl, binding) {
 	repl.server.context[binding] = await app.container.make(binding);
 	repl.notify(`Loaded "${binding}" service. You can access it using the "${repl.colors.underline(binding)}" variable`);
 }
+/**
+* REPL Service Provider configures the interactive Node.js REPL
+* for AdonisJS applications
+*
+* This provider sets up:
+* - REPL instance with history file support
+* - Helper methods for importing modules and making container bindings
+* - Quick access methods for loading common services (app, router, etc.)
+* - Utility methods for development and debugging
+*
+* @example
+* const provider = new ReplServiceProvider(app)
+* provider.register()
+* await provider.boot()
+*/
 var ReplServiceProvider = class {
+	/**
+	* REPL service provider constructor
+	*
+	* @param app - The application service instance
+	*/
 	constructor(app) {
 		this.app = app;
 	}
+	/**
+	* Registers the REPL binding
+	*
+	* Creates a singleton binding for the REPL with history file
+	* support in the user's home directory.
+	*
+	* @example
+	* const provider = new ReplServiceProvider(app)
+	* provider.register()
+	* const repl = await app.container.make('repl')
+	*/
 	register() {
 		this.app.container.singleton(repl_exports.Repl, async () => {
 			return new repl_exports.Repl({ historyFilePath: join(homedir(), ".adonisjs_v6_repl_history") });
 		});
 		this.app.container.alias("repl", repl_exports.Repl);
 	}
+	/**
+	* Registering REPL bindings during provider boot
+	*
+	* Adds helper methods to the REPL instance including:
+	* - importDefault: Import default export from modules
+	* - importAll: Import all files from a directory
+	* - make: Create instances using container.make
+	* - load* methods: Quick access to common services
+	* - loadHelpers: Load utility helper functions
+	*
+	* @example
+	* await provider.boot()
+	* // REPL now has helper methods available
+	*/
 	async boot() {
 		this.app.container.resolving("repl", (repl) => {
 			repl.addMethod("importDefault", (_, modulePath) => {
@@ -65,4 +126,5 @@ var ReplServiceProvider = class {
 		});
 	}
 };
+//#endregion
 export { ReplServiceProvider as default };

package/build/providers/vinejs_provider.js

@@ -1,16 +1,56 @@
-import "../chunk-iKc69rpz.js";
-import { n as RequestValidator, t as main_exports } from "../main-DN2qEEg5.js";
-import { VineMultipartFile } from "../src/vine.js";
+import "../chunk-Do49iUES.js";
+import { n as RequestValidator, t as main_exports } from "../main-Ck0GqLx4.js";
+import { t as VineMultipartFile } from "../vine-DkIupA3Z.js";
 import { Vine } from "@vinejs/vine";
+//#region providers/vinejs_provider.ts
+/**
+* The VineJS service provider integrates VineJS validation
+* library with AdonisJS application environment
+*
+* This provider sets up:
+* - File validation rule for multipart file uploads
+* - Request validation macro for easy validation in HTTP contexts
+* - Extension of VineJS with AdonisJS-specific validation features
+*
+* @example
+* const provider = new VineJSServiceProvider(app)
+* provider.boot()
+* // Now Request has validateUsing method
+*/
 var VineJSServiceProvider = class {
+	/**
+	* VineJS service provider constructor
+	*
+	* Sets the usingVineJS flag to true to indicate VineJS is being used.
+	*
+	* @param app - The application service instance
+	*/
 	constructor(app) {
 		this.app = app;
 		this.app.usingVineJS = true;
 	}
+	/**
+	* Boot the VineJS service provider
+	*
+	* Extends VineJS with file validation macro and adds validateUsing
+	* method to the Request class for easy validation in HTTP contexts.
+	*
+	* @example
+	* provider.boot()
+	* // Now vine.file() and request.validateUsing() are available
+	*/
 	boot() {
+		/**
+		* The file method is used to validate a field to be a valid
+		* multipart file.
+		*/
 		Vine.macro("file", function(options) {
 			return new VineMultipartFile(options);
 		});
+		/**
+		* The validate method can be used to validate the request
+		* data for the current request using VineJS validators
+		*/
 		main_exports.HttpRequest.macro("validateUsing", function(...args) {
 			return new RequestValidator(this.ctx).validateUsing(...args);
 		});
@@ -19,4 +59,5 @@ var VineJSServiceProvider = class {
 		});
 	}
 };
+//#endregion
 export { VineJSServiceProvider as default };

package/build/repl-C02Re0Yd.js

@@ -0,0 +1,7 @@
+import { n as __reExport, t as __exportAll } from "./chunk-Do49iUES.js";
+//#region modules/repl.ts
+var repl_exports = /* @__PURE__ */ __exportAll({});
+import * as import__adonisjs_repl from "@adonisjs/repl";
+__reExport(repl_exports, import__adonisjs_repl);
+//#endregion
+export { repl_exports as t };

package/build/services/ace.js

@@ -1,6 +1,16 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/ace.ts
 let ace;
+/**
+* Returns a singleton instance of the ace kernel
+* from the container.
+*
+* ace service is an instance of the "Kernel" class stored inside
+* the "modules/ace/kernel.ts" file
+*/
 await app.booted(async () => {
 	ace = await app.container.make("ace");
 });
+//#endregion
 export { ace as default };

package/build/services/app.js

@@ -1,5 +1,3 @@
-let app;
-function setApp(appService) {
-	app = appService;
-}
+import "../chunk-Do49iUES.js";
+import { n as setApp, t as app } from "../app-CAuSGb2P.js";
 export { app as default, setApp };

package/build/services/config.js

@@ -1,6 +1,12 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/config.ts
 let config;
+/**
+* The config service uses the config instance from the app service
+*/
 await app.booted(() => {
 	config = app.config;
 });
+//#endregion
 export { config as default };

package/build/services/dumper.js

@@ -1,9 +1,21 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/dumper.ts
 let dumper;
+/**
+* dumper service is an instance of the "Dumper" class stored inside
+* the "modules/dumper/dumper.ts" file
+*/
 await app.booted(async () => {
 	dumper = await app.container.make("dumper");
 });
+/**
+* Dump a value and die. The dumped value will be displayed
+* using the HTML printer during an HTTP request or within
+* the console otherwise.
+*/
 const dd = (value) => {
 	dumper.dd(value, 2);
 };
+//#endregion
 export { dd };

package/build/services/emitter.js

@@ -1,6 +1,13 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/emitter.ts
 let emitter;
+/**
+* Returns a singleton instance of the emitter class
+* from the container
+*/
 await app.booted(async () => {
 	emitter = await app.container.make("emitter");
 });
+//#endregion
 export { emitter as default };

package/build/services/encryption.js

@@ -1,6 +1,13 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/encryption.ts
 let encryption;
+/**
+* Returns a singleton instance of the encryption class
+* from the container
+*/
 await app.booted(async () => {
 	encryption = await app.container.make("encryption");
 });
+//#endregion
 export { encryption as default };

package/build/services/hash.js

@@ -1,6 +1,13 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/hash.ts
 let hash;
+/**
+* Returns a singleton instance of the Hash manager from the
+* container
+*/
 await app.booted(async () => {
 	hash = await app.container.make("hash");
 });
+//#endregion
 export { hash as default };

package/build/services/logger.js

@@ -1,6 +1,13 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/logger.ts
 let logger;
+/**
+* Returns a singleton instance of the logger class
+* from the container
+*/
 await app.booted(async () => {
 	logger = await app.container.make("logger");
 });
+//#endregion
 export { logger as default };

package/build/services/repl.js

@@ -1,6 +1,13 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/repl.ts
 let repl;
+/**
+* Returns a singleton instance of the Repl class from
+* the container
+*/
 await app.booted(async () => {
 	repl = await app.container.make("repl");
 });
+//#endregion
 export { repl as default };

package/build/services/router.js

@@ -1,6 +1,13 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/router.ts
 let router;
+/**
+* Returns a singleton instance of the router class from
+* the container
+*/
 await app.booted(async () => {
 	router = await app.container.make("router");
 });
+//#endregion
 export { router as default };

package/build/services/server.js

@@ -1,6 +1,13 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/server.ts
 let server;
+/**
+* Returns a singleton instance of the HTTP server
+* from the container
+*/
 await app.booted(async () => {
 	server = await app.container.make("server");
 });
+//#endregion
 export { server as default };

package/build/services/test_utils.js

@@ -1,6 +1,16 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/test_utils.ts
 let testUtils;
+/**
+* Returns a singleton instance of the TestUtils class
+* from the container.
+*
+* testUtils service is an instance of the "TestUtils" exported from
+* the "src/test_utils/main.ts" file.
+*/
 await app.booted(async () => {
 	testUtils = await app.container.make("testUtils");
 });
+//#endregion
 export { testUtils as default };

package/build/services/url_builder.js

@@ -1,9 +1,16 @@
-import app from "./app.js";
+import "../chunk-Do49iUES.js";
+import { t as app } from "../app-CAuSGb2P.js";
+//#region services/url_builder.ts
 let urlFor;
 let signedUrlFor;
+/**
+* Returns a singleton instance of the router class from
+* the container
+*/
 await app.booted(async () => {
 	const router = await app.container.make("router");
 	urlFor = router.urlBuilder.urlFor;
 	signedUrlFor = router.urlBuilder.signedUrlFor;
 });
+//#endregion
 export { signedUrlFor, urlFor };

package/build/src/cli_formatters/routes_list.d.ts

@@ -46,6 +46,13 @@ export declare class RoutesListFormatter {
         middleware?: string[];
         ignoreMiddleware?: string[];
     });
+    /**
+     * 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.
+     */
+    formatAsJSONL(): Promise<string[]>;
     /**
      * Formats routes as an array of objects. Routes are grouped by
      * domain.

package/build/src/exceptions.js

@@ -1,2 +1,3 @@
-import { Exception, InvalidArgumentsException, RuntimeException, createError } from "@poppinss/utils/exception";
+import "../chunk-Do49iUES.js";
+import { i as createError, n as InvalidArgumentsException, r as RuntimeException, t as Exception } from "../exceptions-B2MzIlHY.js";
 export { Exception, InvalidArgumentsException, RuntimeException, createError };

package/build/src/helpers/assert.js

@@ -1,2 +1,3 @@
+import "../../chunk-Do49iUES.js";
 import { assertExists, assertIsDefined, assertNotNull, assertUnreachable } from "@poppinss/utils/assert";
 export { assertExists, assertIsDefined, assertNotNull, assertUnreachable };

package/build/src/helpers/http.js

@@ -1,2 +1,3 @@
+import "../../chunk-Do49iUES.js";
 export * from "@adonisjs/http-server/helpers";
 export {};