@adonisjs/core 7.0.1 → 7.1.0

package/build/main-D1MSq4Uu.js

@@ -0,0 +1,435 @@
+import { t as debug_default } from "./debug-DWofTfIX.js";
+import { n as setApp } from "./app-CAuSGb2P.js";
+import { t as app_exports } from "./app-BCcG_oDd.js";
+import { createServer } from "node:http";
+//#region src/ignitor/ace.ts
+/**
+* The Ace process is used to start the application in the
+* console environment. It manages the Ace kernel lifecycle
+* and command execution.
+*
+* @example
+* const ignitor = new Ignitor()
+* const aceProcess = new AceProcess(ignitor)
+*
+* await aceProcess
+*   .configure((app) => {
+*     // Configure ace kernel
+*   })
+*   .handle(['make:controller', 'UserController'])
+*/
+var AceProcess = class {
+	/**
+	* Ignitor reference
+	*/
+	#ignitor;
+	/**
+	* The callback that configures the ace instance before the
+	* handle method is called
+	*/
+	#configureCallback = () => {};
+	/**
+	* Creates a new Ace process instance
+	*
+	* @param ignitor - The ignitor instance used to create and manage the app
+	*/
+	constructor(ignitor) {
+		this.#ignitor = ignitor;
+	}
+	/**
+	* Register a callback that can be used to configure the ace
+	* kernel before the handle method is called
+	*
+	* @param callback - Configuration callback function
+	*/
+	configure(callback) {
+		this.#configureCallback = callback;
+		return this;
+	}
+	/**
+	* Handles the command line arguments and executes
+	* the matching ace commands
+	*
+	* @param argv - Command line arguments array
+	*/
+	async handle(argv) {
+		const app = this.#ignitor.createApp("console");
+		await app.init();
+		const { createAceKernel } = await import("./create_kernel-BV3swyCg.js");
+		const commandName = argv[argv.findIndex((value) => !value.startsWith("-"))];
+		const kernel = createAceKernel(app, commandName);
+		app.container.bindValue("ace", kernel);
+		/**
+		* Hook into kernel and start the app when the
+		* command needs the app.
+		*
+		* Since multiple commands can be executed in a single process,
+		* we add a check to only start the app only once.
+		*/
+		kernel.loading(async (metaData) => {
+			if (metaData.options.startApp && !app.isReady) {
+				if (metaData.commandName === "repl") app.setEnvironment("repl");
+				await app.boot();
+				await app.start(() => {});
+			}
+		});
+		await this.#configureCallback(app);
+		/**
+		* Register terminating callback BEFORE handling the command.
+		* This ensures the callback is registered even if a staysAlive
+		* command calls app.terminate() during its execution.
+		*/
+		app.terminating(() => {
+			const mainCommand = kernel.getMainCommand();
+			if (mainCommand?.staysAlive) process.exitCode = mainCommand.exitCode;
+		});
+		/**
+		* Handle command line args
+		*/
+		await kernel.handle(argv);
+		/**
+		* Terminate the app when the command does not want to
+		* hold a long running process
+		*/
+		const mainCommand = kernel.getMainCommand();
+		if (!mainCommand || !mainCommand.staysAlive) {
+			process.exitCode = kernel.exitCode;
+			await app.terminate();
+		}
+	}
+};
+//#endregion
+//#region src/ignitor/test.ts
+/**
+* The Test runner process is used to start the tests runner process.
+* It provides lifecycle hooks for configuring the test environment
+* and running tests within the AdonisJS application context.
+*
+* @example
+* const ignitor = new Ignitor()
+* const testProcess = new TestRunnerProcess(ignitor)
+*
+* await testProcess
+*   .configure((app) => {
+*     // Configure test environment
+*   })
+*   .run(async (app) => {
+*     // Run your tests
+*   })
+*/
+var TestRunnerProcess = class {
+	/**
+	* Ignitor reference
+	*/
+	#ignitor;
+	/**
+	* The callback that configures the tests runner. This callback
+	* runs at the time of starting the app.
+	*/
+	#configureCallback = () => {};
+	/**
+	* Creates a new test runner process instance
+	*
+	* @param ignitor - The ignitor instance used to create and manage the app
+	*/
+	constructor(ignitor) {
+		this.#ignitor = ignitor;
+	}
+	/**
+	* Register a callback that runs after booting the AdonisJS app
+	* and just before the provider's ready hook
+	*
+	* @param callback - Configuration callback function
+	*/
+	configure(callback) {
+		this.#configureCallback = callback;
+		return this;
+	}
+	/**
+	* Runs a callback after starting the app
+	*
+	* @param callback - Test execution callback function
+	*/
+	async run(callback) {
+		const app = this.#ignitor.createApp("test");
+		await app.init();
+		await app.boot();
+		await app.start(this.#configureCallback);
+		await callback(app);
+	}
+};
+//#endregion
+//#region src/ignitor/http.ts
+/**
+* The HTTP server process is used to start the application in the
+* web environment. It creates and manages the Node.js HTTP server
+* instance, handling lifecycle events and monitoring.
+*
+* @example
+* const ignitor = new Ignitor()
+* const httpProcess = new HttpServerProcess(ignitor)
+* await httpProcess.start()
+*/
+var HttpServerProcess = class {
+	/**
+	* Ignitor reference
+	*/
+	#ignitor;
+	/**
+	* Creates a new HTTP server process instance
+	*
+	* @param ignitor - The ignitor instance used to create and manage the app
+	*/
+	constructor(ignitor) {
+		this.#ignitor = ignitor;
+	}
+	/**
+	* Calling this method closes the underlying HTTP server gracefully.
+	*
+	* @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to close
+	*/
+	#close(nodeHttpServer) {
+		return new Promise((resolve) => {
+			debug_default("closing http server process");
+			nodeHttpServer.close(() => resolve());
+		});
+	}
+	/**
+	* Monitors the app and the server to close the HTTP server when
+	* either one of them goes down. Sets up event listeners for graceful shutdown.
+	*
+	* @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to monitor
+	* @param app - The application service instance
+	* @param logger - The logger service for error reporting
+	*/
+	#monitorAppAndServer(nodeHttpServer, app, logger) {
+		/**
+		* Close the HTTP server when the application begins to
+		* terminate
+		*/
+		app.terminating(async () => {
+			debug_default("terminating signal received");
+			await this.#close(nodeHttpServer);
+		});
+		/**
+		* Terminate the app when the HTTP server crashes
+		*/
+		nodeHttpServer.once("error", (error) => {
+			debug_default("http server crashed with error \"%O\"", error);
+			logger.fatal({ err: error }, error.message);
+			process.exitCode = 1;
+			app.terminate();
+		});
+	}
+	/**
+	* Starts the HTTP server on a given host and port using environment variables.
+	*
+	* @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to start listening
+	*/
+	#listen(nodeHttpServer) {
+		return new Promise((resolve, reject) => {
+			const host = process.env.HOST || "0.0.0.0";
+			const port = Number(process.env.PORT || "3333");
+			nodeHttpServer.listen(port, host);
+			nodeHttpServer.once("listening", () => {
+				debug_default("listening to http server, host :%s, port: %s", host, port);
+				resolve({
+					port,
+					host
+				});
+			});
+			nodeHttpServer.once("error", (error) => {
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Notifies the app and the parent process that the HTTP server is ready.
+	* Sends notifications through multiple channels: parent process, logger, and event emitter.
+	*
+	* @param app - The application service instance for parent process notification
+	* @param logger - The logger service for console output
+	* @param emitter - The event emitter for app-level notifications
+	* @param payload - Server startup information including host, port, and duration
+	*/
+	#notifyServerHasStarted(app, logger, emitter, payload) {
+		/**
+		* Notify parent process
+		*/
+		app.notify({
+			isAdonisJS: true,
+			environment: "web",
+			...payload
+		});
+		/**
+		* Visual notification
+		*/
+		logger.info("started HTTP server on %s:%s", payload.host, payload.port);
+		/**
+		* Notify app
+		*/
+		emitter.emit("http:server_ready", payload);
+	}
+	/**
+	* Start the HTTP server by wiring up the application
+	*
+	* @param serverCallback - Optional callback to create custom HTTP server instance
+	*/
+	async start(serverCallback) {
+		const startTime = process.hrtime();
+		/**
+		* Method to create the HTTP server
+		*/
+		const createHTTPServer = serverCallback || createServer;
+		const app = this.#ignitor.createApp("web");
+		await app.init();
+		await app.boot();
+		await app.start(async () => {
+			/**
+			* Resolve and boot the AdonisJS HTTP server
+			*/
+			const server = await app.container.make("server");
+			await server.boot();
+			/**
+			* Create Node.js HTTP server instance and share it with the
+			* AdonisJS HTTP server
+			*/
+			const httpServer = createHTTPServer(server.handle.bind(server));
+			server.setNodeServer(httpServer);
+			const logger = await app.container.make("logger");
+			const emitter = await app.container.make("emitter");
+			/**
+			* Start the server by listening on a port of host
+			*/
+			const payload = await this.#listen(httpServer);
+			/**
+			* Notify
+			*/
+			this.#notifyServerHasStarted(app, logger, emitter, {
+				...payload,
+				duration: process.hrtime(startTime)
+			});
+			/**
+			* Monitor app and the server (after the server is listening)
+			*/
+			this.#monitorAppAndServer(httpServer, app, logger);
+		});
+	}
+};
+//#endregion
+//#region src/ignitor/main.ts
+/**
+* Ignitor is used to instantiate an AdonisJS application in different
+* known environments. It serves as the main entry point for creating
+* and managing application processes.
+*
+* @example
+* const ignitor = new Ignitor(new URL(import.meta.url))
+*
+* // For HTTP server
+* await ignitor.httpServer().start()
+*
+* // For CLI commands
+* await ignitor.ace().handle(process.argv.slice(2))
+*
+* // For tests
+* await ignitor.testRunner().run(() => {})
+*/
+var Ignitor = class {
+	/**
+	* Ignitor options
+	*/
+	#options;
+	/**
+	* Application root URL
+	*/
+	#appRoot;
+	/**
+	* Reference to the application instance created using
+	* the "createApp" method.
+	*
+	* We store the output of the last call made to "createApp" method
+	* and assume that in one process only one entrypoint will
+	* call this method.
+	*/
+	#app;
+	/**
+	* Reference to the created application
+	*/
+	#tapCallbacks = /* @__PURE__ */ new Set();
+	/**
+	* Creates a new Ignitor instance
+	*
+	* @param appRoot - The root URL of the application
+	* @param options - Configuration options for the ignitor
+	*/
+	constructor(appRoot, options = {}) {
+		this.#appRoot = appRoot;
+		this.#options = options;
+	}
+	/**
+	* Runs all the tap callbacks
+	*/
+	#runTapCallbacks(app) {
+		this.#tapCallbacks.forEach((tapCallback) => tapCallback(app));
+	}
+	/**
+	* Get access to the application instance created
+	* by either the http server process or the ace
+	* process
+	*/
+	getApp() {
+		return this.#app;
+	}
+	/**
+	* Create an instance of AdonisJS application
+	*
+	* @param environment - The environment in which to create the app (web, console, test, repl)
+	*/
+	createApp(environment) {
+		debug_default("creating application instance");
+		this.#app = new app_exports.Application(this.#appRoot, {
+			environment,
+			importer: this.#options.importer
+		});
+		setApp(this.#app);
+		this.#runTapCallbacks(this.#app);
+		return this.#app;
+	}
+	/**
+	* Tap to access the application class instance.
+	*
+	* @param callback - Callback function to execute when app is created
+	*/
+	tap(callback) {
+		this.#tapCallbacks.add(callback);
+		return this;
+	}
+	/**
+	* Get instance of the HTTPServerProcess
+	*/
+	httpServer() {
+		return new HttpServerProcess(this);
+	}
+	/**
+	* Get an instance of the AceProcess class
+	*/
+	ace() {
+		return new AceProcess(this);
+	}
+	/**
+	* Get an instance of the TestRunnerProcess class
+	*/
+	testRunner() {
+		return new TestRunnerProcess(this);
+	}
+	/**
+	* Terminates the app by calling the "app.terminate"
+	* method
+	*/
+	async terminate() {
+		await this.#app?.terminate();
+	}
+};
+//#endregion
+export { Ignitor as t };

package/build/{main--nXd7T-C.js → main-bRYXIHgD.js}

@@ -1,14 +1,41 @@
-import { t as debug_default } from "./debug-CGQmxzGt.js";
-import { t as main_exports } from "./main-DN2qEEg5.js";
-import { Encryption } from "./modules/encryption/main.js";
+import { t as debug_default } from "./debug-DWofTfIX.js";
+import { t as main_exports } from "./main-Ck0GqLx4.js";
+import { n as Encryption } from "./main-CoZI4Ezs.js";
 import { IncomingMessage, ServerResponse, createServer } from "node:http";
 import { Socket } from "node:net";
 import Macroable from "@poppinss/macroable";
+//#region src/test_utils/http.ts
+/**
+* Http server utils are used to start the AdonisJS HTTP server
+* during testing. It provides methods to start and stop the server
+* for integration testing.
+*
+* @example
+* const testUtils = new TestUtils(app)
+* const httpUtils = testUtils.httpServer()
+*
+* const closeServer = await httpUtils.start()
+* // Make HTTP requests to test endpoints
+* await closeServer() // Clean up
+*/
 var HttpServerUtils = class {
+	/**
+	* Reference to the test utils instance
+	*/
 	#utils;
+	/**
+	* Creates a new HttpServerUtils instance
+	*
+	* @param utils - The test utils instance
+	*/
 	constructor(utils) {
 		this.#utils = utils;
 	}
+	/**
+	* Starts the http server a given host and port
+	*
+	* @param nodeHttpServer - The Node.js HTTP server instance
+	*/
 	#listen(nodeHttpServer) {
 		return new Promise((resolve, reject) => {
 			const host = process.env.HOST || "0.0.0.0";
@@ -26,6 +53,12 @@ var HttpServerUtils = class {
 			});
 		});
 	}
+	/**
+	* Testing hook to start the HTTP server to listen for new request.
+	* The return value is a function to close the HTTP server.
+	*
+	* @param serverCallback - Optional callback to create custom HTTP server instance
+	*/
 	async start(serverCallback) {
 		const createHTTPServer = serverCallback || createServer;
 		const server = await this.#utils.app.container.make("server");
@@ -43,24 +76,62 @@ var HttpServerUtils = class {
 		};
 	}
 };
+//#endregion
+//#region src/test_utils/main.ts
+/**
+* Test utils has a collection of helper methods to make testing
+* experience great for AdonisJS applications. It provides utilities
+* for HTTP testing, context creation, and cookie handling.
+*
+* @example
+* const testUtils = new TestUtils(app)
+* await testUtils.boot()
+*
+* const ctx = await testUtils.createHttpContext()
+* const httpUtils = testUtils.httpServer()
+*/
 var TestUtils = class extends Macroable {
+	/**
+	* Flag to track if test utils have been booted
+	*/
 	#booted = false;
+	/**
+	* Check if utils have been booted
+	*/
 	get isBooted() {
 		return this.#booted;
 	}
+	/**
+	* Creates a new TestUtils instance
+	*
+	* @param app - The application service instance
+	*/
 	constructor(app) {
 		super();
 		this.app = app;
 	}
+	/**
+	* Boot test utils. It requires the app to be booted
+	* and container to have all the bindings
+	*/
 	async boot() {
 		if (!this.isBooted) {
 			this.#booted = true;
 			this.cookies = new main_exports.CookieClient(await this.app.container.make(Encryption));
 		}
 	}
+	/**
+	* Returns an instance of the HTTP server testing
+	* utils
+	*/
 	httpServer() {
 		return new HttpServerUtils(this);
 	}
+	/**
+	* Create an instance of HTTP context for testing
+	*
+	* @param options - Options for creating HTTP context with custom req/res objects
+	*/
 	async createHttpContext(options = {}) {
 		const req = options.req || new IncomingMessage(new Socket());
 		const res = options.res || new ServerResponse(req);
@@ -70,4 +141,5 @@ var TestUtils = class extends Macroable {
 		return server.createHttpContext(request, response, this.app.container.createResolver());
 	}
 };
+//#endregion
 export { TestUtils as t };

package/build/main-zxNP7iRl.js

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