@adonisjs/assembler 8.0.0-next.21 → 8.0.0-next.23

package/build/main-1eXSE5Xo.js

@@ -0,0 +1,185 @@
+import { f as throttle, l as removeExtension, m as debug_default, t as VirtualFileSystem } from "./virtual_file_system-DM1KRNbk.js";
+import { mkdir, writeFile } from "node:fs/promises";
+import string from "@poppinss/utils/string";
+import { dirname, join, relative } from "node:path/posix";
+import StringBuilder from "@poppinss/utils/string_builder";
+var FileBuffer = class FileBuffer {
+	#eol = false;
+	#buffer = [];
+	#identationSize = 0;
+	#compiledOutput;
+	create() {
+		return new FileBuffer();
+	}
+	get size() {
+		return this.#buffer.length;
+	}
+	eol(enabled) {
+		this.#eol = enabled;
+		return this;
+	}
+	writeLine(text) {
+		if (typeof text === "string") this.#buffer.push(`${" ".repeat(this.#identationSize)}${text}\n`);
+		else {
+			this.#buffer.push(text);
+			this.#buffer.push("");
+		}
+		return this;
+	}
+	write(text) {
+		if (typeof text === "string") this.#buffer.push(`${" ".repeat(this.#identationSize)}${text}`);
+		else this.#buffer.push(text);
+		return this;
+	}
+	indent() {
+		this.#identationSize += 2;
+		return this;
+	}
+	dedent() {
+		this.#identationSize -= 2;
+		if (this.#identationSize < 0) this.#identationSize = 0;
+		return this;
+	}
+	toString() {
+		return this.flush();
+	}
+	flush() {
+		if (this.#compiledOutput !== void 0) return this.#compiledOutput;
+		this.#compiledOutput = this.#buffer.join("\n");
+		return this.#eol ? `${this.#compiledOutput}\n` : this.#compiledOutput;
+	}
+};
+var IndexGeneratorSource = class {
+	#appRoot;
+	#output;
+	#source;
+	#outputDirname;
+	#vfs;
+	#config;
+	#cliLogger;
+	#generateOutput = throttle(async () => {
+		const buffer = new FileBuffer().eol(true);
+		if (this.#config.as === "barrelFile") this.#asBarrelFile(this.#vfs, buffer, this.#config.exportName, this.#config.disableLazyImports);
+		else this.#config.as(this.#vfs, buffer, this.#config, { toImportPath: this.#createBarrelFileImportGenerator(this.#source, this.#outputDirname, this.#config) });
+		await mkdir(dirname(this.#output), { recursive: true });
+		await writeFile(this.#output, buffer.flush());
+	});
+	name;
+	constructor(name, appRoot, cliLogger, config) {
+		this.name = name;
+		this.#config = config;
+		this.#appRoot = appRoot;
+		this.#cliLogger = cliLogger;
+		this.#source = join(this.#appRoot, this.#config.source);
+		this.#output = join(this.#appRoot, this.#config.output);
+		this.#outputDirname = dirname(this.#output);
+		this.#vfs = new VirtualFileSystem(this.#source, { glob: this.#config.glob });
+	}
+	#treeToString(input, buffer) {
+		Object.keys(input).forEach((key) => {
+			const value = input[key];
+			if (typeof value === "string") buffer.write(`${key}: ${value},`);
+			else {
+				buffer.write(`${key}: {`).indent();
+				this.#treeToString(value, buffer);
+				buffer.dedent().write(`},`);
+			}
+		});
+	}
+	#createBarrelFileKeyGenerator(config) {
+		return function(key) {
+			let paths = key.split("/");
+			let baseName = new StringBuilder(paths.pop());
+			if (config.skipSegments?.length) paths = paths.filter((p) => !config.skipSegments.includes(p));
+			if (config.computeBaseName) baseName = config.computeBaseName(baseName);
+			else baseName = baseName.removeSuffix(config.removeSuffix ?? "").pascalCase();
+			return [...paths.map((p) => string.camelCase(p)), baseName.toString()].join("/");
+		};
+	}
+	#createBarrelFileImportGenerator(source, outputDirname, config) {
+		return function(filePath) {
+			if (config.importAlias) {
+				debug_default("converting \"%s\" to import alias, source \"%s\"", filePath, source);
+				return removeExtension(filePath.replace(source, config.importAlias));
+			}
+			debug_default("converting \"%s\" to relative import, source \"%s\"", filePath, outputDirname);
+			return relative(outputDirname, filePath);
+		};
+	}
+	#asBarrelFile(vfs, buffer, exportName, disableLazyImports) {
+		const useEagerImports = disableLazyImports === true ? true : false;
+		const keyGenerator = this.#createBarrelFileKeyGenerator(this.#config);
+		const importsBuffer = buffer.create();
+		const importGenerator = this.#createBarrelFileImportGenerator(this.#source, this.#outputDirname, this.#config);
+		const tree = vfs.asTree({
+			transformKey: keyGenerator,
+			transformValue: (filePath, key) => {
+				if (useEagerImports) {
+					const importKey = new StringBuilder(key).pascalCase().toString();
+					importsBuffer.write(`import ${importKey} from '${importGenerator(filePath)}'`);
+					return importKey;
+				}
+				return `() => import('${importGenerator(filePath)}')`;
+			}
+		});
+		if (!Object.keys(tree).length) {
+			buffer.write(`export const ${exportName} = {}`);
+			return;
+		}
+		if (useEagerImports) buffer.writeLine(importsBuffer);
+		buffer.write(`export const ${exportName} = {`).indent();
+		this.#treeToString(tree, buffer);
+		buffer.dedent().write(`}`);
+	}
+	#logCreation(startTime) {
+		this.#cliLogger.info(`created ${this.#config.output}`, { startTime });
+	}
+	async addFile(filePath) {
+		if (this.#vfs.add(filePath)) {
+			debug_default("file added, re-generating \"%s\" index", this.name);
+			const startTime = process.hrtime();
+			await this.#generateOutput();
+			this.#logCreation(startTime);
+		}
+	}
+	async removeFile(filePath) {
+		if (this.#vfs.remove(filePath)) {
+			debug_default("file removed, re-generating \"%s\" index", this.name);
+			const startTime = process.hrtime();
+			await this.#generateOutput();
+			this.#logCreation(startTime);
+		}
+	}
+	async generate() {
+		const startTime = process.hrtime();
+		await this.#vfs.scan();
+		await this.#generateOutput();
+		this.#logCreation(startTime);
+	}
+};
+var IndexGenerator = class {
+	appRoot;
+	#sources = {};
+	#cliLogger;
+	constructor(appRoot, cliLogger) {
+		this.appRoot = appRoot;
+		this.#cliLogger = cliLogger;
+	}
+	add(name, config) {
+		this.#sources[name] = new IndexGeneratorSource(name, this.appRoot, this.#cliLogger, config);
+		return this;
+	}
+	async addFile(filePath) {
+		const sources = Object.values(this.#sources);
+		for (let source of sources) await source.addFile(filePath);
+	}
+	async removeFile(filePath) {
+		const sources = Object.values(this.#sources);
+		for (let source of sources) await source.removeFile(filePath);
+	}
+	async generate() {
+		const sources = Object.values(this.#sources);
+		for (let source of sources) await source.generate();
+	}
+};
+export { FileBuffer as n, IndexGenerator as t };

package/build/main-Byxt3AdL.js

@@ -0,0 +1,240 @@
+import { i as isRelative, m as debug_default, t as VirtualFileSystem } from "./virtual_file_system-DM1KRNbk.js";
+import { a as nodeToPlainText, i as inspectMethodArguments, n as inspectClass, o as searchValidatorDirectUsage, r as inspectClassMethods, t as findImport } from "./helpers-DDurYRsZ.js";
+import { cliui } from "@poppinss/cliui";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import string from "@poppinss/utils/string";
+import { join, relative } from "node:path";
+import StringBuilder from "@poppinss/utils/string_builder";
+import { parseImports } from "parse-imports";
+import { resolve } from "import-meta-resolve";
+var PathsResolver = class {
+	#appRoot;
+	#resolvedPaths = {};
+	#resolver = (specifier, parentPath) => resolve(specifier, parentPath);
+	constructor(appRoot) {
+		this.#appRoot = pathToFileURL(join(appRoot, "index.js")).href;
+	}
+	use(resolver) {
+		this.#resolver = resolver;
+	}
+	resolve(specifier, rewriteAliasImportExtension = false) {
+		if (isRelative(specifier)) throw new Error("Cannot resolve relative paths using PathsResolver");
+		const cacheKey = specifier;
+		const cached = this.#resolvedPaths[cacheKey];
+		if (cached) return cached;
+		let resolvedPath = fileURLToPath(this.#resolver(specifier, this.#appRoot));
+		if (rewriteAliasImportExtension && specifier.startsWith("#") && resolvedPath.endsWith(".js")) resolvedPath = resolvedPath.replace(/\.js$/, ".ts");
+		this.#resolvedPaths[cacheKey] = resolvedPath;
+		return this.#resolvedPaths[cacheKey];
+	}
+};
+async function extractValidators(appRoot, vfs, controller) {
+	const root = await vfs.get(controller.path);
+	const fileContents = root.text();
+	const controllerClass = inspectClass(root);
+	if (!controllerClass) {
+		debug_default(`No class defined within the "%s"`, controller.import.specifier);
+		return;
+	}
+	const method = inspectClassMethods(controllerClass).find((methodNode) => {
+		return methodNode.find({ rule: { kind: "property_identifier" } })?.text() === controller.method;
+	});
+	if (!method) {
+		debug_default(`Unable to find "%s" method in "%s"`, controller.method, controller.import.specifier);
+		return;
+	}
+	const validationCalls = inspectMethodArguments(method, ["request.validateUsing", "vine.validate"]).map((node) => {
+		const firstArg = node.find({ rule: { any: [{ kind: "identifier" }, { kind: "member_expression" }] } });
+		if (!firstArg) return;
+		return nodeToPlainText(firstArg);
+	}).filter((node) => node !== void 0).concat(searchValidatorDirectUsage(method).map((node) => nodeToPlainText(node)));
+	if (!validationCalls.length) {
+		debug_default(`Unable to detect any validation calls in "%s.%s" method`, controller.import.specifier, controller.method);
+		return;
+	}
+	const controllerName = controllerClass.find({ rule: { kind: "type_identifier" } }).text();
+	const controllerURL = pathToFileURL(controller.path);
+	return (await Promise.all(validationCalls.map(async (validationCall) => {
+		if (validationCall.split(".")[0] === controllerName) return {
+			name: validationCall,
+			import: {
+				specifier: controller.import.specifier,
+				type: "default",
+				value: controllerName
+			}
+		};
+		const importCall = await findImport(fileContents, validationCall);
+		if (!importCall) {
+			debug_default("Unable to find import for \"%s\" used by \"%s.%s\" method", validationCall, controller.import.specifier, controller.method);
+			return null;
+		}
+		return {
+			name: validationCall,
+			import: {
+				specifier: isRelative(importCall.specifier) ? string.toUnixSlash(relative(appRoot, fileURLToPath(new URL(importCall.specifier, controllerURL)))) : importCall.specifier,
+				type: importCall.clause.type,
+				value: importCall.clause.value
+			}
+		};
+	}))).filter((value) => !!value);
+}
+var RoutesScanner = class {
+	#appRoot;
+	#controllerRoutes = {};
+	#scannedRoutes = [];
+	#computeResponseTypes;
+	#computeRequestTypes;
+	#extractValidators;
+	ui = cliui();
+	pathsResolver;
+	rules = {
+		skip: [],
+		request: {},
+		response: {}
+	};
+	constructor(appRoot, rulesCollection) {
+		this.#appRoot = appRoot;
+		this.pathsResolver = new PathsResolver(appRoot);
+		rulesCollection.forEach((rules) => {
+			this.rules.skip = this.rules.skip.concat(rules.skip);
+			Object.assign(this.rules.request, rules.request);
+			Object.assign(this.rules.response, rules.response);
+		});
+		this.rules.skip = Array.from(new Set([...this.rules.skip]));
+	}
+	#prepareRequestTypes(route) {
+		if (!route.validators) return;
+		return {
+			type: route.validators.reduce((result, validator) => {
+				const validatorExport = validator.import.type === "default" ? ".default" : validator.import.type === "named" ? `.${validator.import.value}` : "";
+				const [, ...segments] = validator.name.split(".");
+				const namespace = segments.map((segment) => `['${segment}']`).join("");
+				result.push(`Infer<(typeof import('${validator.import.specifier}')${validatorExport})${namespace}>`);
+				return result;
+			}, []).join("|"),
+			imports: [`import { Infer } from '@vinejs/vine/types'`]
+		};
+	}
+	async #inspectControllerSpecifier(importExpression, method) {
+		const importedModule = [...await parseImports(importExpression)].find(($import) => $import.isDynamicImport && $import.moduleSpecifier.value);
+		if (!importedModule || importedModule.moduleSpecifier.type !== "package" || !importedModule.moduleSpecifier.value) return null;
+		const specifier = importedModule.moduleSpecifier.value;
+		const name = new StringBuilder(specifier.split("/").pop()).removeSuffix("Controller").pascalCase().suffix("Controller").toString();
+		return {
+			name,
+			method: method ?? "handle",
+			path: string.toUnixSlash(this.pathsResolver.resolve(specifier, true)),
+			import: {
+				specifier,
+				type: "default",
+				value: name
+			}
+		};
+	}
+	async #setResponse(route, controller) {
+		route.response = await this.#computeResponseTypes?.(route, controller, this) ?? {
+			type: `ReturnType<import('${controller.import.specifier}').default['${controller.method}']>`,
+			imports: []
+		};
+		debug_default("computed route \"%s\" response %O", route.name, route.response);
+	}
+	async #setRequest(route, controller, vfs) {
+		route.validators = await this.#extractValidators?.(route, controller, this) ?? await extractValidators(this.#appRoot, vfs, controller);
+		debug_default("computed route \"%s\" validators %O", route.name, route.validators);
+		route.request = await this.#computeRequestTypes?.(route, controller, this) ?? this.#prepareRequestTypes(route);
+		debug_default("computed route \"%s\" request input %O", route.name, route.request);
+	}
+	#processRouteWithoutController(route) {
+		if (!route.name) {
+			debug_default(`skipping route "%s" as it does not have a name`, route.pattern);
+			return;
+		}
+		const scannedRoute = {
+			name: route.name,
+			domain: route.domain,
+			methods: route.methods,
+			pattern: route.pattern,
+			tokens: route.tokens,
+			request: this.rules.request[route.name],
+			response: this.rules.response[route.name]
+		};
+		debug_default("scanned route without controller %O", scannedRoute);
+		this.#scannedRoutes.push(scannedRoute);
+	}
+	async #processRouteWithController(route, vfs) {
+		if (!route.handler || !route.handler.importExpression) return this.#processRouteWithoutController(route);
+		const controller = await this.#inspectControllerSpecifier(route.handler.importExpression, route.handler.method);
+		if (!controller) return this.#processRouteWithoutController(route);
+		debug_default("processing route \"%s\" with inspected controller %O", route.name, controller);
+		const routeName = route.name ?? new StringBuilder(controller.name).removeSuffix("Controller").snakeCase().suffix(`.${string.snakeCase(controller.method)}`).toString();
+		if (this.rules.skip.includes(routeName)) return;
+		const scannedRoute = {
+			name: routeName,
+			domain: route.domain,
+			methods: route.methods,
+			pattern: route.pattern,
+			tokens: route.tokens,
+			request: this.rules.request[routeName],
+			response: this.rules.response[routeName],
+			controller
+		};
+		debug_default("scanned route %O", scannedRoute);
+		this.#scannedRoutes.push(scannedRoute);
+		if (!scannedRoute.request || !scannedRoute.response) {
+			debug_default("tracking controller for rescanning %O", scannedRoute);
+			this.#controllerRoutes[controller.path] ??= [];
+			this.#controllerRoutes[controller.path].push(scannedRoute);
+			if (!scannedRoute.response) await this.#setResponse(scannedRoute, controller);
+			if (!scannedRoute.request) await this.#setRequest(scannedRoute, controller, vfs);
+		}
+	}
+	async #processRoute(route, vfs) {
+		if (route.name && this.rules.skip.includes(route.name)) {
+			debug_default("route skipped route: %O, rules: %O", route, this.rules);
+			return;
+		}
+		if (typeof route.handler === "function") {
+			this.#processRouteWithoutController(route);
+			return;
+		}
+		await this.#processRouteWithController(route, vfs);
+	}
+	defineResponse(callback) {
+		this.#computeResponseTypes = callback;
+		return this;
+	}
+	defineRequest(callback) {
+		this.#computeRequestTypes = callback;
+		return this;
+	}
+	extractValidators(callback) {
+		this.#extractValidators = callback;
+		return this;
+	}
+	getScannedRoutes() {
+		return this.#scannedRoutes;
+	}
+	getControllers() {
+		return Object.keys(this.#controllerRoutes);
+	}
+	async invalidate(controllerPath) {
+		const controllerRoutes = this.#controllerRoutes[controllerPath];
+		if (!controllerRoutes || !controllerRoutes.length) {
+			debug_default("\"%s\" controllers is not part of scanned controllers %O", controllerPath, this.#controllerRoutes);
+			return false;
+		}
+		for (let scannedRoute of controllerRoutes) if (scannedRoute.controller) {
+			debug_default("invalidating route %O", scannedRoute);
+			const vfs = new VirtualFileSystem(this.#appRoot);
+			await this.#setResponse(scannedRoute, scannedRoute.controller);
+			await this.#setRequest(scannedRoute, scannedRoute.controller, vfs);
+		}
+		return true;
+	}
+	async scan(routes) {
+		const vfs = new VirtualFileSystem(this.#appRoot);
+		for (const route of routes) await this.#processRoute(route, vfs);
+		vfs.invalidate();
+	}
+};
+export { RoutesScanner as t };

package/build/src/code_scanners/routes_scanner/main.js

@@ -1,8 +1,4 @@
-import {
-  RoutesScanner
-} from "../../../chunk-NAASGAFO.js";
-import "../../../chunk-TIKQQRMX.js";
-import "../../../chunk-JFBQ4OEM.js";
-export {
-  RoutesScanner
-};
+import "../../../virtual_file_system-DM1KRNbk.js";
+import { t as RoutesScanner } from "../../../main-Byxt3AdL.js";
+import "../../../helpers-DDurYRsZ.js";
+export { RoutesScanner };