@adonisjs/core 7.0.0-next.9 → 7.0.1

package/build/core-IpCOCkUL.js

@@ -0,0 +1,146 @@
+import stringHelpers from "./src/helpers/string.js";
+import { r as outputTransformerDataObjects } from "./utils-rRkbAPnP.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,
+		inertiaMiddlewareImportPath: "#middleware/inertia_middleware",
+		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,
+			comment: true
+		});
+		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,
+			comment: true
+		});
+		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,
+			comment: true
+		});
+		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) => stringHelpers.pascalCase(segment)), stringHelpers.create(baseName).removeSuffix("transformer").pascalCase()].join("/");
+					},
+					transformValue: helpers.toImportPath
+				}), buffer, transformers.withSharedProps, transformers.inertiaMiddlewareImportPath);
+			},
+			importAlias: transformers.importAlias,
+			output: transformers.output,
+			comment: true
+		});
+		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,
+			comment: true
+		});
+	} };
+}
+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-B7ILNhuP.js

@@ -0,0 +1,38 @@
+import { d as Kernel, n as HelpCommand, t as FsLoader } from "./main-MBAMnmJb.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/create_kernel-BD0Iqi8e.js

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

package/build/debug-CGQmxzGt.js

@@ -0,0 +1,3 @@
+import { debuglog } from "node:util";
+var debug_default = debuglog("adonisjs:core");
+export { debug_default as t };

package/build/decorate-DmrZA614.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-0oHaj43l.js

@@ -0,0 +1,86 @@
+import { t as debug_default } from "./debug-CGQmxzGt.js";
+import { t as configProvider } from "./config_provider-FIAUgvae.js";
+import { InvalidArgumentsException } from "./src/exceptions.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.filter((key) => !!key)
+			};
+		});
+	},
+	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.filter((key) => !!key)
+			};
+		});
+	},
+	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.filter((key) => !!key)
+			};
+		});
+	},
+	aessiv: (config) => {
+		return configProvider.create(async () => {
+			const { AESSIV } = await import("./modules/encryption/drivers/aes_siv.js");
+			debug_default("configuring aessiv encryption driver");
+			return {
+				driver: (key) => new AESSIV({
+					id: config.id,
+					key
+				}),
+				keys: [config.key].filter((key) => !!key)
+			};
+		});
+	},
+	legacy: (config) => {
+		return configProvider.create(async () => {
+			const { Legacy } = await import("./modules/encryption/drivers/legacy.js");
+			debug_default("configuring legacy encryption driver");
+			return {
+				driver: (key) => new Legacy({ key }),
+				keys: config.keys.filter((key) => !!key)
+			};
+		});
+	}
+};
+export { drivers as n, defineConfig as t };

package/build/dumper-BBgqFX5a.js

@@ -0,0 +1,147 @@
+import { t as __exportAll } from "./chunk-iKc69rpz.js";
+import { inspect } from "node:util";
+import { Exception } from "@poppinss/utils/exception";
+import useColors from "@poppinss/colors";
+import { dump } from "@poppinss/dumper/console";
+import { createScript, createStyleSheet, dump as dump$1 } from "@poppinss/dumper/html";
+import { parse } from "error-stack-parser-es";
+var errors_exports = /* @__PURE__ */ __exportAll({ E_DUMP_DIE_EXCEPTION: () => E_DUMP_DIE_EXCEPTION });
+var DumpDieException = class extends Exception {
+	static status = 500;
+	static code = "E_DUMP_DIE_EXCEPTION";
+	#dumper;
+	#traceSourceIndex = 1;
+	value;
+	constructor(value, dumper) {
+		super("Dump and Die exception");
+		this.#dumper = dumper;
+		this.value = value;
+	}
+	#getErrorSource() {
+		if (this.fileName && this.lineNumber) return {
+			location: this.fileName,
+			line: this.lineNumber
+		};
+		const source = parse(this)[this.#traceSourceIndex];
+		if (!source.fileName || !source.lineNumber) return;
+		return {
+			location: source.fileName,
+			line: source.lineNumber
+		};
+	}
+	setTraceSourceIndex(index) {
+		this.#traceSourceIndex = index;
+		return this;
+	}
+	report() {}
+	async handle(error, ctx) {
+		const source = this.#getErrorSource();
+		const cspNonce = "nonce" in ctx.response ? ctx.response.nonce : void 0;
+		ctx.response.status(500).send(`<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width">${this.#dumper.getHeadElements(cspNonce)}</head><body>${this.#dumper.dumpToHtml(error.value, {
+			cspNonce,
+			source,
+			title: "DUMP DIE"
+		})}</body></html>`);
+	}
+	async render(error, kernel) {
+		const source = this.#getErrorSource();
+		kernel.ui.logger.log(this.#dumper.dumpToAnsi(error.value, {
+			source,
+			title: "DUMP DIE"
+		}));
+	}
+	[inspect.custom]() {
+		const source = this.#getErrorSource();
+		return this.#dumper.dumpToAnsi(this.value, {
+			source,
+			title: "DUMP DIE"
+		});
+	}
+};
+const E_DUMP_DIE_EXCEPTION = DumpDieException;
+const colors = useColors.ansi();
+const DUMP_TITLE_STYLES = `
+.adonisjs-dump-header {
+  font-family: JetBrains Mono, monaspace argon, Menlo, Monaco, Consolas, monospace;
+  background: #ff1639;
+  border-radius: 4px;
+  color: #fff;
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+  padding: 0.4rem 1.2rem;
+  font-size: 1em;
+  display: flex;
+  justify-content: space-between;
+}
+.adonisjs-dump-header .adonisjs-dump-header-title {
+  font-weight: bold;
+  text-transform: uppercase;
+}
+.adonisjs-dump-header .adonisjs-dump-header-source {
+  font-weight: bold;
+  color: inherit;
+  text-decoration: underline;
+}
+.dumper-dump pre {
+  border-radius: 4px;
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}`;
+const IDE = process.env.ADONIS_IDE ?? process.env.EDITOR ?? "";
+var Dumper = class {
+	#app;
+	#htmlConfig = {};
+	#consoleConfig = { collapse: ["DateTime", "Date"] };
+	#editors = {
+		textmate: "txmt://open?url=file://%f&line=%l",
+		macvim: "mvim://open?url=file://%f&line=%l",
+		emacs: "emacs://open?url=file://%f&line=%l",
+		sublime: "subl://open?url=file://%f&line=%l",
+		phpstorm: "phpstorm://open?file=%f&line=%l",
+		atom: "atom://core/open/file?filename=%f&line=%l",
+		vscode: "vscode://file/%f:%l"
+	};
+	constructor(app) {
+		this.#app = app;
+	}
+	#getEditorLink(source) {
+		const editorURL = this.#editors[IDE] || IDE;
+		if (!editorURL || !source) return;
+		return {
+			href: editorURL.replace("%f", source.location).replace("%l", String(source.line)),
+			text: `${this.#app.relativePath(source.location)}:${source.line}`
+		};
+	}
+	configureHtmlOutput(config) {
+		this.#htmlConfig = config;
+		return this;
+	}
+	configureAnsiOutput(config) {
+		this.#consoleConfig = config;
+		return this;
+	}
+	getHeadElements(cspNonce) {
+		return `<style id="dumper-styles">` + createStyleSheet() + DUMP_TITLE_STYLES + `</style><script id="dumper-script"${cspNonce ? ` nonce="${cspNonce}"` : ""}>` + createScript() + "<\/script>";
+	}
+	dumpToHtml(value, options = {}) {
+		const link = this.#getEditorLink(options.source) ?? null;
+		return `<div class="adonisjs-dump-header"><span class="adonisjs-dump-header-title">${options.title || "DUMP"}</span>` + (link ? `<a href="${link.href}" class="adonisjs-dump-header-source">${link.text}</a>` : "") + "</div>" + dump$1(value, {
+			cspNonce: options.cspNonce,
+			...this.#htmlConfig
+		});
+	}
+	dumpToAnsi(value, options = {}) {
+		const columns = process.stdout.columns;
+		const link = `${this.#getEditorLink(options.source)?.text ?? ""} `;
+		const title = ` ${options.title || "DUMP"}`;
+		const whiteSpaceLength = columns ? columns - link.length - title.length - 4 : 2;
+		const whiteSpace = new Array(whiteSpaceLength <= 0 ? 2 : whiteSpaceLength).join(" ");
+		return `${colors.bgRed().bold(`${title}${whiteSpace}${link}`)}\n${dump(value, this.#consoleConfig)}`;
+	}
+	dd(value, traceSourceIndex = 1) {
+		const error = new E_DUMP_DIE_EXCEPTION(value, this);
+		error.setTraceSourceIndex(traceSourceIndex);
+		throw error;
+	}
+};
+export { errors_exports as n, Dumper as t };

package/build/errors-CrCO-k44.js

@@ -0,0 +1,8 @@
+import { createError } from "./src/exceptions.js";
+import { errors } from "@boringnode/encryption";
+const E_BLIND_INDEX_NOT_SUPPORTED = createError("Blind indexes are not supported by the \"%s\" encryption driver", "E_BLIND_INDEX_NOT_SUPPORTED");
+const errors$1 = {
+	...errors,
+	E_BLIND_INDEX_NOT_SUPPORTED
+};
+export { errors$1 as n, E_BLIND_INDEX_NOT_SUPPORTED as t };

package/build/factories/app.js

@@ -1,9 +1,2 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export * from '@adonisjs/application/factories';
+export * from "@adonisjs/application/factories";
+export {};

package/build/factories/bodyparser.js

@@ -1,9 +1,2 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export * from '@adonisjs/bodyparser/factories';
+export * from "@adonisjs/bodyparser/factories";
+export {};

package/build/factories/core/ace.js

@@ -1,46 +1,23 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
+import "../../chunk-iKc69rpz.js";
+import "../../debug-CGQmxzGt.js";
+import { t as Ignitor } from "../../main-Cxz0TyIw.js";
+import "../../config_provider-FIAUgvae.js";
+import "../../main-MBAMnmJb.js";
+import "../../main-DN2qEEg5.js";
+import "../../define_config-0oHaj43l.js";
+import "../../main-DkNgvceD.js";
 import { IgnitorFactory } from "./ignitor.js";
-import { Ignitor } from "../../src/ignitor/main.js";
-import { createAceKernel } from "../../modules/ace/create_kernel.js";
-/**
- * Factory for creating and configuring Ace command kernel instances.
- * This factory provides a convenient way to create Ace kernels either from
- * an existing Ignitor instance or by creating a new one from scratch.
- *
- * @example
- * ```ts
- * // Create from URL
- * const aceFactory = new AceFactory()
- * const kernel = await aceFactory.make(new URL('../', import.meta.url))
- *
- * // Create from existing ignitor
- * const ignitor = new Ignitor(appRoot)
- * const kernel = await aceFactory.make(ignitor)
- *
- * // Run commands
- * await kernel.handle(['make:controller', 'UserController'])
- * ```
- */
-export class AceFactory {
-    async make(ignitorOrAppRoot, options) {
-        if (ignitorOrAppRoot instanceof Ignitor) {
-            const app = ignitorOrAppRoot.createApp('console');
-            await app.init();
-            return createAceKernel(app);
-        }
-        const app = new IgnitorFactory()
-            .withCoreConfig()
-            .withCoreProviders()
-            .create(ignitorOrAppRoot, options)
-            .createApp('console');
-        await app.init();
-        return createAceKernel(app);
-    }
-}
+import { t as createAceKernel } from "../../create_kernel-B7ILNhuP.js";
+var AceFactory = class {
+	async make(ignitorOrAppRoot, options) {
+		if (ignitorOrAppRoot instanceof Ignitor) {
+			const app = ignitorOrAppRoot.createApp("console");
+			await app.init();
+			return createAceKernel(app);
+		}
+		const app = new IgnitorFactory().withCoreConfig().withCoreProviders().create(ignitorOrAppRoot, options).createApp("console");
+		await app.init();
+		return createAceKernel(app);
+	}
+};
+export { AceFactory };