@adonisjs/core 7.0.0-next.2 → 7.0.0-next.20

package/build/commands/test.js

@@ -1,209 +1,93 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+import { t as importAssembler } from "../utils-CtGytdtt.js";
+import { f as BaseCommand, l as flags, o as args } from "../main-BlJhxJJ2.js";
+import { t as __decorate } from "../decorate-CJcHOoD-.js";
+var Test = class extends BaseCommand {
+	static commandName = "test";
+	static description = "Run tests along with the file watcher to re-run tests on file change";
+	static options = {
+		allowUnknownFlags: true,
+		staysAlive: true
+	};
+	#logMissingDevelopmentDependency(dependency) {
+		this.logger.error([
+			`Cannot find package "${dependency}"`,
+			"",
+			`The "${dependency}" package is a development dependency and therefore you should run tests with development dependencies installed.`,
+			"",
+			"If you are run tests inside a CI, make sure the NODE_ENV is set to \"development\""
+		].join("\n"));
+	}
+	#getPassthroughFlags() {
+		return this.parsed.unknownFlags.map((flag) => {
+			const value = this.parsed.flags[flag];
+			if (value === true) return [`--${flag}`];
+			if (Array.isArray(value)) return value.map((v) => [`--${flag}`, v]);
+			return [`--${flag}`, value];
+		}).flat(2);
+	}
+	async run() {
+		process.env.NODE_ENV = "test";
+		const assembler = await importAssembler(this.app);
+		if (!assembler) {
+			this.#logMissingDevelopmentDependency("@adonisjs/assembler");
+			this.exitCode = 1;
+			return;
+		}
+		this.testsRunner = new assembler.TestRunner(this.app.appRoot, {
+			clearScreen: this.clear === false ? false : true,
+			nodeArgs: this.parsed.nodeArgs,
+			scriptArgs: this.#getPassthroughFlags(),
+			filters: {
+				suites: this.suites,
+				files: this.files,
+				groups: this.groups,
+				tags: this.tags,
+				tests: this.tests
+			},
+			failed: this.failed,
+			retries: this.retries,
+			timeout: this.timeout,
+			reporters: this.reporters,
+			suites: this.app.rcFile.tests.suites.map((suite) => {
+				return {
+					name: suite.name,
+					files: suite.files
+				};
+			}),
+			env: { NODE_ENV: "test" },
+			hooks: this.app.rcFile.hooks,
+			metaFiles: this.app.rcFile.metaFiles
+		});
+		this.testsRunner.ui.logger = this.logger;
+		this.testsRunner.onClose((exitCode) => {
+			this.exitCode = exitCode;
+			this.terminate();
+		});
+		this.testsRunner.onError(() => {
+			this.exitCode = 1;
+			this.terminate();
+		});
+		if (this.watch) await this.testsRunner.runAndWatch({ poll: this.poll || false });
+		else await this.testsRunner.run();
+	}
 };
-import { BaseCommand, flags, args } from "../modules/ace/main.js";
-import { importAssembler, importTypeScript } from "../src/utils.js";
-/**
- * Command to run application tests using the Japa test runner.
- * Supports filtering tests by suites, files, tags, groups, and individual tests.
- * Can run in watch mode to automatically re-run tests when files change.
- *
- * @example
- * ```
- * ace test
- * ace test unit integration
- * ace test --watch
- * ace test --files=user.spec.ts
- * ace test --tags=slow --groups="User tests"
- * ace test --reporters=spec,dot
- * ace test --timeout=5000 --retries=2
- * ```
- */
-export default class Test extends BaseCommand {
-    /**
-     * The command name
-     */
-    static commandName = 'test';
-    /**
-     * The command description
-     */
-    static description = 'Run tests along with the file watcher to re-run tests on file change';
-    /**
-     * Command options configuration.
-     * Allows unknown flags to be passed to Japa and keeps the process alive.
-     */
-    static options = {
-        allowUnknownFlags: true,
-        staysAlive: true,
-    };
-    /**
-     * Log an error message when a required development dependency is missing.
-     * Provides helpful instructions for resolving the issue.
-     *
-     * @param dependency - The name of the missing dependency package
-     */
-    #logMissingDevelopmentDependency(dependency) {
-        this.logger.error([
-            `Cannot find package "${dependency}"`,
-            '',
-            `The "${dependency}" package is a development dependency and therefore you should run tests with development dependencies installed.`,
-            '',
-            'If you are run tests inside a CI, make sure the NODE_ENV is set to "development"',
-        ].join('\n'));
-    }
-    /**
-     * Collect unknown flags and format them to pass to the Japa test runner.
-     * Handles boolean flags, arrays, and single values appropriately.
-     *
-     * @returns Array of formatted command-line arguments for Japa
-     */
-    #getPassthroughFlags() {
-        return this.parsed.unknownFlags
-            .map((flag) => {
-            const value = this.parsed.flags[flag];
-            /**
-             * Not mentioning value when value is "true"
-             */
-            if (value === true) {
-                return [`--${flag}`];
-            }
-            /**
-             * Repeating flag multiple times when value is an array
-             */
-            if (Array.isArray(value)) {
-                return value.map((v) => [`--${flag}`, v]);
-            }
-            return [`--${flag}`, value];
-        })
-            .flat(2);
-    }
-    /**
-     * Execute the test command. Sets up the test runner with all configured options
-     * and filters, then runs tests either once or in watch mode. Handles missing
-     * dependencies and properly configures the test environment.
-     */
-    async run() {
-        process.env.NODE_ENV = 'test';
-        const assembler = await importAssembler(this.app);
-        if (!assembler) {
-            this.#logMissingDevelopmentDependency('@adonisjs/assembler');
-            this.exitCode = 1;
-            return;
-        }
-        this.testsRunner = new assembler.TestRunner(this.app.appRoot, {
-            clearScreen: this.clear === false ? false : true,
-            nodeArgs: this.parsed.nodeArgs,
-            scriptArgs: this.#getPassthroughFlags(),
-            filters: {
-                suites: this.suites,
-                files: this.files,
-                groups: this.groups,
-                tags: this.tags,
-                tests: this.tests,
-            },
-            failed: this.failed,
-            retries: this.retries,
-            timeout: this.timeout,
-            reporters: this.reporters,
-            suites: this.app.rcFile.tests.suites.map((suite) => {
-                return {
-                    name: suite.name,
-                    files: suite.files,
-                };
-            }),
-            env: {
-                NODE_ENV: 'test',
-            },
-            hooks: this.app.rcFile.hooks,
-            metaFiles: this.app.rcFile.metaFiles,
-        });
-        /**
-         * Share command logger with assembler, so that CLI flags like --no-ansi has
-         * similar impact for assembler logs as well.
-         */
-        this.testsRunner.ui.logger = this.logger;
-        /**
-         * Exit command when the test runner is closed
-         */
-        this.testsRunner.onClose((exitCode) => {
-            this.exitCode = exitCode;
-            this.terminate();
-        });
-        /**
-         * Exit command when the dev server crashes
-         */
-        this.testsRunner.onError(() => {
-            this.exitCode = 1;
-            this.terminate();
-        });
-        /**
-         * Start the test runner in watch mode
-         */
-        if (this.watch) {
-            const ts = await importTypeScript(this.app);
-            if (!ts) {
-                this.#logMissingDevelopmentDependency('typescript');
-                this.exitCode = 1;
-                return;
-            }
-            await this.testsRunner.runAndWatch(ts, { poll: this.poll || false });
-        }
-        else {
-            await this.testsRunner.run();
-        }
-    }
-}
-__decorate([
-    args.spread({
-        description: 'Mention suite names to run tests for selected suites',
-        required: false,
-    })
-], Test.prototype, "suites", void 0);
-__decorate([
-    flags.array({ description: 'Filter tests by the filename' })
-], Test.prototype, "files", void 0);
-__decorate([
-    flags.array({ description: 'Filter tests by tags' })
-], Test.prototype, "tags", void 0);
-__decorate([
-    flags.array({ description: 'Filter tests by parent group title' })
-], Test.prototype, "groups", void 0);
-__decorate([
-    flags.array({ description: 'Filter tests by test title' })
-], Test.prototype, "tests", void 0);
-__decorate([
-    flags.array({ description: 'Activate one or more test reporters' })
-], Test.prototype, "reporters", void 0);
-__decorate([
-    flags.boolean({ description: 'Watch filesystem and re-run tests on file change' })
-], Test.prototype, "watch", void 0);
-__decorate([
-    flags.boolean({ description: 'Use polling to detect filesystem changes' })
-], Test.prototype, "poll", void 0);
-__decorate([
-    flags.number({ description: 'Define default timeout for all tests' })
-], Test.prototype, "timeout", void 0);
-__decorate([
-    flags.number({ description: 'Define default retries for all tests' })
-], Test.prototype, "retries", void 0);
-__decorate([
-    flags.boolean({ description: 'Execute tests failed during the last run' })
-], Test.prototype, "failed", void 0);
-__decorate([
-    flags.boolean({
-        description: 'Clear the terminal for new logs after file change',
-        showNegatedVariantInHelp: true,
-        default: true,
-    })
-], Test.prototype, "clear", void 0);
+__decorate([args.spread({
+	description: "Mention suite names to run tests for selected suites",
+	required: false
+})], Test.prototype, "suites", void 0);
+__decorate([flags.array({ description: "Filter tests by the filename" })], Test.prototype, "files", void 0);
+__decorate([flags.array({ description: "Filter tests by tags" })], Test.prototype, "tags", void 0);
+__decorate([flags.array({ description: "Filter tests by parent group title" })], Test.prototype, "groups", void 0);
+__decorate([flags.array({ description: "Filter tests by test title" })], Test.prototype, "tests", void 0);
+__decorate([flags.array({ description: "Activate one or more test reporters" })], Test.prototype, "reporters", void 0);
+__decorate([flags.boolean({ description: "Watch filesystem and re-run tests on file change" })], Test.prototype, "watch", void 0);
+__decorate([flags.boolean({ description: "Use polling to detect filesystem changes" })], Test.prototype, "poll", void 0);
+__decorate([flags.number({ description: "Define default timeout for all tests" })], Test.prototype, "timeout", void 0);
+__decorate([flags.number({ description: "Define default retries for all tests" })], Test.prototype, "retries", void 0);
+__decorate([flags.boolean({ description: "Execute tests failed during the last run" })], Test.prototype, "failed", void 0);
+__decorate([flags.boolean({
+	description: "Clear the terminal for new logs after file change",
+	showNegatedVariantInHelp: true,
+	default: true
+})], Test.prototype, "clear", void 0);
+export { Test as default };

package/build/config-Dd2H6-_e.js

@@ -0,0 +1,5 @@
+import { n as __reExport } from "./chunk-B88MteZI.js";
+var config_exports = {};
+import * as import__adonisjs_config from "@adonisjs/config";
+__reExport(config_exports, import__adonisjs_config);
+export { config_exports as t };

package/build/config_provider-DWVFHOQX.js

@@ -0,0 +1,15 @@
+import { debuglog } from "node:util";
+var debug_default = debuglog("adonisjs:core");
+const configProvider = {
+	create(resolver) {
+		return {
+			type: "provider",
+			resolver
+		};
+	},
+	async resolve(app, provider) {
+		if (provider && typeof provider === "object" && "type" in provider) return provider.resolver(app);
+		return null;
+	}
+};
+export { debug_default as n, configProvider as t };

package/build/container-uxa8LpGI.js

@@ -0,0 +1,5 @@
+import { n as __reExport } from "./chunk-B88MteZI.js";
+var container_exports = {};
+import * as import__adonisjs_fold from "@adonisjs/fold";
+__reExport(container_exports, import__adonisjs_fold);
+export { container_exports as t };

package/build/core-BuPP8K6N.js

@@ -0,0 +1,140 @@
+import { t as string_default } from "./string-Cx6q_win.js";
+import { r as outputTransformerDataObjects } from "./utils-CtGytdtt.js";
+import { errors } from "@adonisjs/ace";
+import { errors as errors$1 } from "@adonisjs/env";
+import { errors as errors$2 } from "@adonisjs/application";
+import { errors as errors$3 } from "@boringnode/encryption";
+import { errors as errors$4 } from "@adonisjs/http-server";
+function indexEntities(entities = {}) {
+	const events = Object.assign({
+		enabled: true,
+		source: "app/events",
+		importAlias: "#events",
+		skipSegments: ["events"],
+		output: ".adonisjs/server/events.ts"
+	}, entities.events);
+	const listeners = Object.assign({
+		enabled: true,
+		source: "app/listeners",
+		importAlias: "#listeners",
+		skipSegments: ["listeners"],
+		output: ".adonisjs/server/listeners.ts"
+	}, entities.listeners);
+	const controllers = Object.assign({
+		enabled: true,
+		source: "app/controllers",
+		importAlias: "#controllers",
+		skipSegments: ["controllers"],
+		output: ".adonisjs/server/controllers.ts"
+	}, entities.controllers);
+	const transformers = Object.assign({
+		enabled: false,
+		source: "app/transformers",
+		importAlias: "#transformers",
+		withSharedProps: false,
+		skipSegments: ["transformers"],
+		output: ".adonisjs/client/data.d.ts"
+	}, entities.transformers);
+	const manifest = {
+		enabled: entities.manifest?.enabled === false ? false : transformers.enabled,
+		source: "config",
+		output: ".adonisjs/client/manifest.d.ts",
+		exclude: entities.manifest?.exclude ?? [
+			"app.ts",
+			"bodyparser.ts",
+			"cors.ts",
+			"database.ts",
+			"encryption.ts",
+			"inertia.ts",
+			"session.ts",
+			"shield.ts",
+			"static.ts",
+			"vite.ts"
+		]
+	};
+	return { run(_, __, indexGenerator) {
+		if (events.enabled) indexGenerator.add("events", {
+			source: events.source,
+			disableLazyImports: true,
+			glob: events.glob,
+			as: "barrelFile",
+			exportName: "events",
+			importAlias: events.importAlias,
+			skipSegments: events.skipSegments,
+			output: events.output
+		});
+		if (listeners.enabled) indexGenerator.add("listeners", {
+			source: listeners.source,
+			glob: listeners.glob,
+			as: "barrelFile",
+			exportName: "listeners",
+			importAlias: listeners.importAlias,
+			skipSegments: listeners.skipSegments,
+			output: listeners.output
+		});
+		if (controllers.enabled) indexGenerator.add("controllers", {
+			source: controllers.source,
+			glob: controllers.glob,
+			as: "barrelFile",
+			exportName: "controllers",
+			importAlias: controllers.importAlias,
+			skipSegments: controllers.skipSegments,
+			removeSuffix: "controller",
+			output: controllers.output
+		});
+		if (transformers.enabled) indexGenerator.add("transformers", {
+			source: transformers.source,
+			glob: transformers.glob,
+			as(vfs, buffer, ___, helpers) {
+				outputTransformerDataObjects(vfs.asTree({
+					transformKey(key) {
+						let segments = key.split("/");
+						const baseName = segments.pop();
+						if (transformers.skipSegments?.length) segments = segments.filter((s) => !transformers.skipSegments.includes(s));
+						return [...segments.map((segment) => string_default.pascalCase(segment)), string_default.create(baseName).removeSuffix("transformer").pascalCase()].join("/");
+					},
+					transformValue: helpers.toImportPath
+				}), buffer, transformers.withSharedProps);
+			},
+			importAlias: transformers.importAlias,
+			output: transformers.output
+		});
+		if (manifest.enabled) indexGenerator.add("manifest", {
+			source: manifest.source,
+			filter: (filePath, isDirectory) => {
+				if (isDirectory) return true;
+				if (!manifest.exclude?.length) return true;
+				return !manifest.exclude.find((include) => filePath.endsWith(include));
+			},
+			as(vfs, buffer, ___, helpers) {
+				const configFilesList = vfs.asList();
+				buffer.write(`/// <reference path="../../adonisrc.ts" />`);
+				Object.values(configFilesList).forEach((value) => {
+					buffer.write(`/// <reference path="${helpers.toImportPath(value)}" />`);
+				});
+			},
+			output: manifest.output
+		});
+	} };
+}
+const errors$5 = {
+	...errors$3,
+	...errors$4,
+	...errors$2,
+	...errors,
+	...errors$1
+};
+async function prettyPrintError(error) {
+	if (error && typeof error === "object" && error.code === "E_DUMP_DIE_EXCEPTION") {
+		console.error(error);
+		return;
+	}
+	try {
+		const { Youch } = await import("youch");
+		const youch = new Youch();
+		console.error(await youch.toANSI(error));
+	} catch {
+		console.error(error);
+	}
+}
+export { prettyPrintError as n, indexEntities as r, errors$5 as t };

package/build/create_kernel-Cn8zVtvt.js

@@ -0,0 +1,3 @@
+import "./main-BlJhxJJ2.js";
+import { t as createAceKernel } from "./create_kernel-Cpqqa931.js";
+export { createAceKernel };

package/build/create_kernel-Cpqqa931.js

@@ -0,0 +1,38 @@
+import { d as Kernel, n as HelpCommand, t as FsLoader } from "./main-BlJhxJJ2.js";
+function createAceKernel(app, commandName) {
+	const kernel = new Kernel(app);
+	kernel.info.set("binary", "node ace");
+	app.rcFile.commands.forEach((commandModule) => {
+		kernel.addLoader(() => typeof commandModule === "function" ? commandModule() : app.import(commandModule));
+	});
+	const fsLoader = new FsLoader(app.commandsPath());
+	kernel.addLoader({
+		async getMetaData() {
+			if (!commandName || !kernel.getCommand(commandName)) return fsLoader.getMetaData();
+			return [];
+		},
+		getCommand(command) {
+			return fsLoader.getCommand(command);
+		}
+	});
+	kernel.defineFlag("ansi", {
+		type: "boolean",
+		showNegatedVariantInHelp: true,
+		description: "Force enable or disable colorful output"
+	});
+	kernel.defineFlag("help", {
+		type: "boolean",
+		description: HelpCommand.description
+	});
+	kernel.on("ansi", (_, $kernel, parsed) => {
+		if (parsed.flags.ansi === false) $kernel.ui.switchMode("silent");
+		if (parsed.flags.ansi === true) $kernel.ui.switchMode("normal");
+	});
+	kernel.on("help", async (command, $kernel, parsed) => {
+		parsed.args.unshift(command.commandName);
+		await new HelpCommand($kernel, parsed, kernel.ui, kernel.prompt).exec();
+		return $kernel.shortcircuit();
+	});
+	return kernel;
+}
+export { createAceKernel as t };

package/build/decorate-CJcHOoD-.js

@@ -0,0 +1,7 @@
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+export { __decorate as t };

package/build/define_config-CoWy5lbf.js

@@ -0,0 +1,62 @@
+import { n as debug_default, t as configProvider } from "./config_provider-DWVFHOQX.js";
+import { n as InvalidArgumentsException } from "./exceptions-DNMesP42.js";
+function defineConfig(config) {
+	if (!config.list) throw new InvalidArgumentsException("Missing \"list\" property in encryption config");
+	if (config.default && !config.list[config.default]) throw new InvalidArgumentsException(`Missing "list.${String(config.default)}" in encryption config. It is referenced by the "default" property`);
+	return configProvider.create(async (app) => {
+		debug_default("resolving encryption config");
+		const encryptorsList = Object.keys(config.list);
+		const encryptors = {};
+		for (let encryptorName of encryptorsList) {
+			const encryptor = config.list[encryptorName];
+			if ("resolver" in encryptor) encryptors[encryptorName] = await encryptor.resolver(app);
+			else encryptors[encryptorName] = encryptor;
+		}
+		return {
+			default: config.default,
+			list: encryptors
+		};
+	});
+}
+const drivers = {
+	chacha20: (config) => {
+		return configProvider.create(async () => {
+			const { ChaCha20Poly1305 } = await import("./modules/encryption/drivers/chacha20_poly1305.js");
+			debug_default("configuring chacha20 encryption driver");
+			return {
+				driver: (key) => new ChaCha20Poly1305({
+					id: config.id,
+					key
+				}),
+				keys: config.keys
+			};
+		});
+	},
+	aes256cbc: (config) => {
+		return configProvider.create(async () => {
+			const { AES256CBC } = await import("./modules/encryption/drivers/aes_256_cbc.js");
+			debug_default("configuring aes256cbc encryption driver");
+			return {
+				driver: (key) => new AES256CBC({
+					id: config.id,
+					key
+				}),
+				keys: config.keys
+			};
+		});
+	},
+	aes256gcm: (config) => {
+		return configProvider.create(async () => {
+			const { AES256GCM } = await import("./modules/encryption/drivers/aes_256_gcm.js");
+			debug_default("configuring aes256gcm encryption driver");
+			return {
+				driver: (key) => new AES256GCM({
+					id: config.id,
+					key
+				}),
+				keys: config.keys
+			};
+		});
+	}
+};
+export { drivers as n, defineConfig as t };