@adonisjs/assembler 8.0.0-next.26 → 8.0.0-next.28

package/build/codemod_exception-vyN1VXuX.js

@@ -0,0 +1,137 @@
+var CodemodException = class CodemodException extends Error {
+	instructions;
+	filePath;
+	constructor(message, options) {
+		super(message);
+		this.name = "CodemodException";
+		this.instructions = options?.instructions;
+		this.filePath = options?.filePath;
+	}
+	static #formatEnvValidations(definition) {
+		const lines = [];
+		if (definition.leadingComment) {
+			lines.push(`/*`);
+			lines.push(`|----------------------------------------------------------`);
+			lines.push(`| ${definition.leadingComment}`);
+			lines.push(`|----------------------------------------------------------`);
+			lines.push(`*/`);
+		}
+		for (const [variable, validation] of Object.entries(definition.variables)) lines.push(`${variable}: ${validation},`);
+		return lines.join("\n");
+	}
+	static #formatMiddleware(stack, middleware) {
+		if (stack === "named") return `export const middleware = router.named({\n  ${middleware.filter((m) => m.name).map((m) => `${m.name}: () => import('${m.path}')`).join(",\n  ")}\n})`;
+		return `${stack}.use([\n  ${middleware.map((m) => `() => import('${m.path}')`).join(",\n  ")}\n])`;
+	}
+	static #formatPolicies(policies) {
+		return `export const policies = {\n  ${policies.map((p) => `${p.name}: () => import('${p.path}')`).join(",\n  ")}\n}`;
+	}
+	static #formatVitePlugin(pluginCall, importDeclarations) {
+		return `${importDeclarations.map((decl) => decl.isNamed ? `import { ${decl.identifier} } from '${decl.module}'` : `import ${decl.identifier} from '${decl.module}'`).join("\n")}\n\nexport default defineConfig({\n  plugins: [${pluginCall}]\n})`;
+	}
+	static #formatJapaPlugin(pluginCall, importDeclarations) {
+		return `${importDeclarations.map((decl) => decl.isNamed ? `import { ${decl.identifier} } from '${decl.module}'` : `import ${decl.identifier} from '${decl.module}'`).join("\n")}\n\nexport const plugins: Config['plugins'] = [\n  ${pluginCall}\n]`;
+	}
+	static missingEnvFile(filePath, definition) {
+		const code = this.#formatEnvValidations(definition);
+		return new CodemodException(`Could not find source file at path: "${filePath}"`, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${code}`
+		});
+	}
+	static missingEnvCreate(filePath, definition) {
+		return new CodemodException(`Cannot find Env.create statement in the file.`, {
+			filePath,
+			instructions: `Add the following code inside Env.create() in "${filePath}":\n\n${this.#formatEnvValidations(definition)}`
+		});
+	}
+	static invalidEnvCreate(filePath, definition) {
+		return new CodemodException(`The second argument of Env.create is not an object literal.`, {
+			filePath,
+			instructions: `Add the following code inside Env.create() in "${filePath}":\n\n${this.#formatEnvValidations(definition)}`
+		});
+	}
+	static missingKernelFile(filePath, stack, middleware) {
+		const code = this.#formatMiddleware(stack, middleware);
+		return new CodemodException(`Could not find source file at path: "${filePath}"`, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${code}`
+		});
+	}
+	static missingMiddlewareStack(filePath, stack, middleware) {
+		const code = this.#formatMiddleware(stack, middleware);
+		return new CodemodException(`Cannot find ${stack === "named" ? "middleware variable" : `${stack}.use`} statement in the file.`, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${code}`
+		});
+	}
+	static invalidMiddlewareStack(filePath, stack, middleware, reason) {
+		return new CodemodException(reason, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${this.#formatMiddleware(stack, middleware)}`
+		});
+	}
+	static missingPoliciesFile(filePath, policies) {
+		const code = this.#formatPolicies(policies);
+		return new CodemodException(`Could not find source file at path: "${filePath}"`, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${code}`
+		});
+	}
+	static invalidPoliciesFile(filePath, policies, reason) {
+		return new CodemodException(reason, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${this.#formatPolicies(policies)}`
+		});
+	}
+	static missingViteConfig(filePath, pluginCall, importDeclarations) {
+		return new CodemodException(`Cannot find vite.config.ts file. Make sure to rename vite.config.js to vite.config.ts`, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${this.#formatVitePlugin(pluginCall, importDeclarations)}`
+		});
+	}
+	static invalidViteConfig(filePath, pluginCall, importDeclarations, reason) {
+		return new CodemodException(reason, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${this.#formatVitePlugin(pluginCall, importDeclarations)}`
+		});
+	}
+	static missingJapaBootstrap(filePath, pluginCall, importDeclarations) {
+		const code = this.#formatJapaPlugin(pluginCall, importDeclarations);
+		return new CodemodException(`Could not find source file at path: "${filePath}"`, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${code}`
+		});
+	}
+	static invalidJapaBootstrap(filePath, pluginCall, importDeclarations, reason) {
+		return new CodemodException(reason, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${this.#formatJapaPlugin(pluginCall, importDeclarations)}`
+		});
+	}
+	static missingRcFile(filePath, codeToAdd) {
+		return new CodemodException(`Could not find source file at path: "${filePath}"`, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${codeToAdd}`
+		});
+	}
+	static invalidRcFile(filePath, codeToAdd, reason) {
+		return new CodemodException(reason, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${codeToAdd}`
+		});
+	}
+	static E_CODEMOD_FILE_NOT_FOUND(filePath, codeToAdd) {
+		return new CodemodException(`Could not find source file at path: "${filePath}"`, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${codeToAdd}`
+		});
+	}
+	static E_CODEMOD_INVALID_STRUCTURE(message, filePath, codeToAdd) {
+		return new CodemodException(message, {
+			filePath,
+			instructions: `Add the following code to "${filePath}":\n\n${codeToAdd}`
+		});
+	}
+};
+export { CodemodException as t };

package/build/index.d.ts

@@ -3,4 +3,5 @@ export { DevServer } from './src/dev_server.ts';
 export { TestRunner } from './src/test_runner.ts';
 export { FileBuffer } from './src/file_buffer.ts';
 export { VirtualFileSystem } from './src/virtual_file_system.ts';
+export { CodemodException } from './src/exceptions/codemod_exception.ts';
 export { SUPPORTED_PACKAGE_MANAGERS } from './src/bundler.ts';

package/build/index.js

@@ -1,7 +1,8 @@
 import { a as loadHooks, c as readTsConfig, d as runNode, f as throttle, m as debug_default, n as copyFiles, o as memoize, p as watch, r as getPort, s as parseConfig, t as VirtualFileSystem, u as run } from "./virtual_file_system-bGeoWsK-.js";
 import { n as FileBuffer, t as IndexGenerator } from "./main-XUXlmlEy.js";
-import { t as RoutesScanner } from "./main-BSWlOK0F.js";
+import { t as RoutesScanner } from "./main-BeV45LeF.js";
 import "./helpers-DDurYRsZ.js";
+import { t as CodemodException } from "./codemod_exception-vyN1VXuX.js";
 import dedent from "dedent";
 import fs, { readFile, unlink } from "node:fs/promises";
 import { cliui } from "@poppinss/cliui";
@@ -934,4 +935,4 @@ var TestRunner = class {
 		});
 	}
 };
-export { Bundler, DevServer, FileBuffer, SUPPORTED_PACKAGE_MANAGERS, TestRunner, VirtualFileSystem };
+export { Bundler, CodemodException, DevServer, FileBuffer, SUPPORTED_PACKAGE_MANAGERS, TestRunner, VirtualFileSystem };

package/build/{main-BSWlOK0F.js → main-BeV45LeF.js}

@@ -111,10 +111,10 @@ var RoutesScanner = class {
 				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}>`);
+				result.push(`InferInput<(typeof import('${validator.import.specifier}')${validatorExport})${namespace}>`);
 				return result;
 			}, []).join("|"),
-			imports: [`import { Infer } from '@vinejs/vine/types'`]
+			imports: [`import { InferInput } from '@vinejs/vine/types'`]
 		};
 	}
 	async #inspectControllerSpecifier(importExpression, method) {

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

@@ -1,4 +1,4 @@
 import "../../../virtual_file_system-bGeoWsK-.js";
-import { t as RoutesScanner } from "../../../main-BSWlOK0F.js";
+import { t as RoutesScanner } from "../../../main-BeV45LeF.js";
 import "../../../helpers-DDurYRsZ.js";
 export { RoutesScanner };

package/build/src/code_transformer/main.d.ts

@@ -39,6 +39,15 @@ export declare class CodeTransformer {
      * @param cwd - The current working directory URL
      */
     constructor(cwd: URL);
+    /**
+     * Get directories configured in adonisrc.ts, with defaults fallback.
+     *
+     * This method reads the adonisrc.ts file and extracts the directories
+     * configuration. If a directory is not configured, the default value is used.
+     *
+     * @returns Object containing directory paths
+     */
+    getDirectories(): Record<string, string>;
     /**
      * Add new env variable validation in the `env.ts` file
      *

package/build/src/code_transformer/main.js

@@ -1,3 +1,4 @@
+import { t as CodemodException } from "../../codemod_exception-vyN1VXuX.js";
 import { fileURLToPath } from "node:url";
 import { detectPackageManager, installPackage } from "@antfu/install-pkg";
 import { join } from "node:path";
@@ -24,8 +25,15 @@ var RcFileTransformer = class {
 		this.#project = project;
 	}
 	#getRcFileOrThrow() {
-		const kernelUrl = fileURLToPath(new URL("./adonisrc.ts", this.#cwd));
-		return this.#project.getSourceFileOrThrow(kernelUrl);
+		const filePath = "adonisrc.ts";
+		const rcFileUrl = fileURLToPath(new URL(`./${filePath}`, this.#cwd));
+		const file = this.#project.getSourceFile(rcFileUrl);
+		if (!file) throw CodemodException.missingRcFile(filePath, `import { defineConfig } from '@adonisjs/core/app'
+
+export default defineConfig({
+  // Add your configuration here
+})`);
+		return file;
 	}
 	#isInSpecificEnvironment(environments) {
 		if (!environments) return false;
@@ -33,7 +41,11 @@ var RcFileTransformer = class {
 	}
 	#locateDefineConfigCallOrThrow(file) {
 		const call = file.getDescendantsOfKind(SyntaxKind.CallExpression).find((statement) => statement.getExpression().getText() === "defineConfig");
-		if (!call) throw new Error("Could not locate the defineConfig call.");
+		if (!call) throw CodemodException.invalidRcFile("adonisrc.ts", `import { defineConfig } from '@adonisjs/core/app'
+
+export default defineConfig({
+  // Add your configuration here
+})`, "Could not locate the defineConfig call.");
 		return call;
 	}
 	#getDefineConfigObjectOrThrow(defineConfigCall) {
@@ -142,6 +154,23 @@ var RcFileTransformer = class {
 		hooksArray.addElement(`() => import('${path}')`);
 		return this;
 	}
+	getDirectory(key, defaultValue) {
+		try {
+			const file = this.#getRcFileOrThrow();
+			const defineConfigCall = this.#locateDefineConfigCallOrThrow(file);
+			const directoriesProperty = this.#getDefineConfigObjectOrThrow(defineConfigCall).getProperty("directories");
+			if (!directoriesProperty || !Node.isPropertyAssignment(directoriesProperty)) return defaultValue;
+			const directoriesObject = directoriesProperty.getInitializer();
+			if (!directoriesObject || !Node.isObjectLiteralExpression(directoriesObject)) return defaultValue;
+			const property = directoriesObject.getProperty(key);
+			if (!property || !Node.isPropertyAssignment(property)) return defaultValue;
+			const initializer = property.getInitializer();
+			if (!initializer || !Node.isStringLiteral(initializer)) return defaultValue;
+			return initializer.getLiteralValue();
+		} catch {
+			return defaultValue;
+		}
+	}
 	save() {
 		const file = this.#getRcFileOrThrow();
 		file.formatText(this.#editorSettings);
@@ -170,6 +199,14 @@ var CodeTransformer = class {
 			manipulationSettings: { quoteKind: QuoteKind.Single }
 		});
 	}
+	getDirectories() {
+		const rcFileTransformer = new RcFileTransformer(this.#cwd, this.project);
+		return {
+			start: rcFileTransformer.getDirectory("start", "start"),
+			tests: rcFileTransformer.getDirectory("tests", "tests"),
+			policies: rcFileTransformer.getDirectory("policies", "app/policies")
+		};
+	}
 	#addToMiddlewareArray(file, target, middlewareEntry) {
 		const callExpressions = file.getDescendantsOfKind(SyntaxKind.CallExpression).filter((statement) => statement.getExpression().getText() === target);
 		if (!callExpressions.length) throw new Error(`Cannot find ${target} statement in the file.`);
@@ -217,12 +254,14 @@ var CodeTransformer = class {
 		return writer.blankLine().writeLine("/*").writeLine(`|----------------------------------------------------------`).writeLine(`| ${comment}`).writeLine(`|----------------------------------------------------------`).writeLine(`*/`);
 	}
 	async defineEnvValidations(definition) {
-		const kernelUrl = join(this.#cwdPath, "./start/env.ts");
-		const file = this.project.getSourceFileOrThrow(kernelUrl);
+		const filePath = `${this.getDirectories().start}/env.ts`;
+		const envUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(envUrl);
+		if (!file) throw CodemodException.missingEnvFile(filePath, definition);
 		const callExpressions = file.getDescendantsOfKind(SyntaxKind.CallExpression).filter((statement) => statement.getExpression().getText() === "Env.create");
-		if (!callExpressions.length) throw new Error(`Cannot find Env.create statement in the file.`);
+		if (!callExpressions.length) throw CodemodException.missingEnvCreate(filePath, definition);
 		const objectLiteralExpression = callExpressions[0].getArguments()[1];
-		if (!Node.isObjectLiteralExpression(objectLiteralExpression)) throw new Error(`The second argument of Env.create is not an object literal.`);
+		if (!Node.isObjectLiteralExpression(objectLiteralExpression)) throw CodemodException.invalidEnvCreate(filePath, definition);
 		let shouldAddComment = true;
 		for (const [variable, validation] of Object.entries(definition.variables)) {
 			const existingProperty = objectLiteralExpression.getProperty(variable);
@@ -241,10 +280,17 @@ var CodeTransformer = class {
 		await file.save();
 	}
 	async addMiddlewareToStack(stack, middleware) {
-		const kernelUrl = join(this.#cwdPath, "./start/kernel.ts");
-		const file = this.project.getSourceFileOrThrow(kernelUrl);
-		for (const middlewareEntry of middleware) if (stack === "named") this.#addToNamedMiddleware(file, middlewareEntry);
-		else this.#addToMiddlewareArray(file, `${stack}.use`, middlewareEntry);
+		const filePath = `${this.getDirectories().start}/kernel.ts`;
+		const kernelUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(kernelUrl);
+		if (!file) throw CodemodException.missingKernelFile(filePath, stack, middleware);
+		try {
+			for (const middlewareEntry of middleware) if (stack === "named") this.#addToNamedMiddleware(file, middlewareEntry);
+			else this.#addToMiddlewareArray(file, `${stack}.use`, middlewareEntry);
+		} catch (error) {
+			if (error instanceof Error) throw CodemodException.invalidMiddlewareStack(filePath, stack, middleware, error.message);
+			throw error;
+		}
 		file.formatText(this.#editorSettings);
 		await file.save();
 	}
@@ -254,8 +300,10 @@ var CodeTransformer = class {
 		await rcFileTransformer.save();
 	}
 	async addJapaPlugin(pluginCall, importDeclarations) {
-		const testBootstrapUrl = join(this.#cwdPath, "./tests/bootstrap.ts");
-		const file = this.project.getSourceFileOrThrow(testBootstrapUrl);
+		const filePath = `${this.getDirectories().tests}/bootstrap.ts`;
+		const testBootstrapUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(testBootstrapUrl);
+		if (!file) throw CodemodException.missingJapaBootstrap(filePath, pluginCall, importDeclarations);
 		this.#addImportDeclarations(file, importDeclarations);
 		const pluginsArray = file.getVariableDeclaration("plugins")?.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
 		if (pluginsArray) {
@@ -265,22 +313,36 @@ var CodeTransformer = class {
 		await file.save();
 	}
 	async addVitePlugin(pluginCall, importDeclarations) {
-		const viteConfigTsUrl = join(this.#cwdPath, "./vite.config.ts");
+		const filePath = "vite.config.ts";
+		const viteConfigTsUrl = join(this.#cwdPath, `./${filePath}`);
 		const file = this.project.getSourceFile(viteConfigTsUrl);
-		if (!file) throw new Error("Cannot find vite.config.ts file. Make sure to rename vite.config.js to vite.config.ts");
-		this.#addImportDeclarations(file, importDeclarations);
-		const defaultExport = file.getDefaultExportSymbol();
-		if (!defaultExport) throw new Error("Cannot find the default export in vite.config.ts");
-		const declaration = defaultExport.getDeclarations()[0];
-		const pluginsArray = (declaration.getChildrenOfKind(SyntaxKind.ObjectLiteralExpression)[0] || declaration.getChildrenOfKind(SyntaxKind.CallExpression)[0].getArguments()[0]).getPropertyOrThrow("plugins").getFirstChildByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-		if (!pluginsArray.getElements().find((element) => element.getText() === pluginCall)) pluginsArray.addElement(pluginCall);
+		if (!file) throw CodemodException.missingViteConfig(filePath, pluginCall, importDeclarations);
+		try {
+			this.#addImportDeclarations(file, importDeclarations);
+			const defaultExport = file.getDefaultExportSymbol();
+			if (!defaultExport) throw new Error("Cannot find the default export in vite.config.ts");
+			const declaration = defaultExport.getDeclarations()[0];
+			const pluginsArray = (declaration.getChildrenOfKind(SyntaxKind.ObjectLiteralExpression)[0] || declaration.getChildrenOfKind(SyntaxKind.CallExpression)[0].getArguments()[0]).getPropertyOrThrow("plugins").getFirstChildByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+			if (!pluginsArray.getElements().find((element) => element.getText() === pluginCall)) pluginsArray.addElement(pluginCall);
+		} catch (error) {
+			if (error instanceof CodemodException) throw error;
+			if (error instanceof Error) throw CodemodException.invalidViteConfig(filePath, pluginCall, importDeclarations, error.message);
+			throw error;
+		}
 		file.formatText(this.#editorSettings);
 		await file.save();
 	}
 	async addPolicies(policies) {
-		const kernelUrl = join(this.#cwdPath, "./app/policies/main.ts");
-		const file = this.project.getSourceFileOrThrow(kernelUrl);
-		for (const policy of policies) this.#addToPoliciesList(file, policy);
+		const filePath = `${this.getDirectories().policies}/main.ts`;
+		const policiesUrl = join(this.#cwdPath, `./${filePath}`);
+		const file = this.project.getSourceFile(policiesUrl);
+		if (!file) throw CodemodException.missingPoliciesFile(filePath, policies);
+		try {
+			for (const policy of policies) this.#addToPoliciesList(file, policy);
+		} catch (error) {
+			if (error instanceof Error) throw CodemodException.invalidPoliciesFile(filePath, policies, error.message);
+			throw error;
+		}
 		file.formatText(this.#editorSettings);
 		await file.save();
 	}

package/build/src/code_transformer/rc_file_transformer.d.ts

@@ -88,6 +88,14 @@ export declare class RcFileTransformer {
      * @returns This RcFileTransformer instance for method chaining
      */
     addAssemblerHook(type: keyof Exclude<AssemblerRcFile['hooks'], undefined>, path: string): this;
+    /**
+     * Get a directory value from the directories configuration.
+     *
+     * @param key - The directory key to retrieve
+     * @param defaultValue - The default value if not configured
+     * @returns The configured directory path or the default value
+     */
+    getDirectory(key: string, defaultValue: string): string;
     /**
      * Save the adonisrc.ts file with all applied transformations
      *

package/build/src/exceptions/codemod_exception.d.ts

@@ -0,0 +1,178 @@
+import type { MiddlewareNode, EnvValidationNode, BouncerPolicyNode } from '../types/code_transformer.ts';
+/**
+ * Options for creating a CodemodException
+ */
+export interface CodemodExceptionOptions {
+    /**
+     * Instructions for the user to manually perform the codemod action
+     */
+    instructions?: string;
+    /**
+     * The file path that was being modified
+     */
+    filePath?: string;
+}
+/**
+ * Custom exception for codemod errors that provides helpful instructions
+ * to the user when automatic code transformation fails.
+ *
+ * @example
+ * ```ts
+ * throw CodemodException.missingEnvFile('start/env.ts', {
+ *   variables: { MY_VAR: 'Env.schema.string()' }
+ * })
+ * ```
+ */
+export declare class CodemodException extends Error {
+    #private;
+    /**
+     * Instructions for the user to manually perform the codemod action
+     */
+    instructions?: string;
+    /**
+     * The file path that was being modified
+     */
+    filePath?: string;
+    constructor(message: string, options?: CodemodExceptionOptions);
+    /**
+     * Creates an exception when start/env.ts file is missing
+     *
+     * @param filePath - The path to the missing file
+     * @param definition - The environment validation definition that was being added
+     */
+    static missingEnvFile(filePath: string, definition: EnvValidationNode): CodemodException;
+    /**
+     * Creates an exception when Env.create is not found in the file
+     *
+     * @param filePath - The path to the file being modified
+     * @param definition - The environment validation definition that was being added
+     */
+    static missingEnvCreate(filePath: string, definition: EnvValidationNode): CodemodException;
+    /**
+     * Creates an exception when Env.create has invalid structure
+     *
+     * @param filePath - The path to the file being modified
+     * @param definition - The environment validation definition that was being added
+     */
+    static invalidEnvCreate(filePath: string, definition: EnvValidationNode): CodemodException;
+    /**
+     * Creates an exception when start/kernel.ts file is missing
+     *
+     * @param filePath - The path to the missing file
+     * @param stack - The middleware stack that was being modified
+     * @param middleware - The middleware entries that were being added
+     */
+    static missingKernelFile(filePath: string, stack: 'server' | 'router' | 'named', middleware: MiddlewareNode[]): CodemodException;
+    /**
+     * Creates an exception when server.use/router.use is not found
+     *
+     * @param filePath - The path to the file being modified
+     * @param stack - The middleware stack that was being modified
+     * @param middleware - The middleware entries that were being added
+     */
+    static missingMiddlewareStack(filePath: string, stack: 'server' | 'router' | 'named', middleware: MiddlewareNode[]): CodemodException;
+    /**
+     * Creates an exception when middleware array structure is invalid
+     *
+     * @param filePath - The path to the file being modified
+     * @param stack - The middleware stack that was being modified
+     * @param middleware - The middleware entries that were being added
+     * @param reason - The reason why the structure is invalid
+     */
+    static invalidMiddlewareStack(filePath: string, stack: 'server' | 'router' | 'named', middleware: MiddlewareNode[], reason: string): CodemodException;
+    /**
+     * Creates an exception when app/policies/main.ts file is missing
+     *
+     * @param filePath - The path to the missing file
+     * @param policies - The policies that were being added
+     */
+    static missingPoliciesFile(filePath: string, policies: BouncerPolicyNode[]): CodemodException;
+    /**
+     * Creates an exception when policies structure is invalid
+     *
+     * @param filePath - The path to the file being modified
+     * @param policies - The policies that were being added
+     * @param reason - The reason why the structure is invalid
+     */
+    static invalidPoliciesFile(filePath: string, policies: BouncerPolicyNode[], reason: string): CodemodException;
+    /**
+     * Creates an exception when vite.config.ts file is missing
+     *
+     * @param filePath - The path to the missing file
+     * @param pluginCall - The plugin call that was being added
+     * @param importDeclarations - The import declarations needed for the plugin
+     */
+    static missingViteConfig(filePath: string, pluginCall: string, importDeclarations: {
+        isNamed: boolean;
+        module: string;
+        identifier: string;
+    }[]): CodemodException;
+    /**
+     * Creates an exception when vite.config.ts structure is invalid
+     *
+     * @param filePath - The path to the file being modified
+     * @param pluginCall - The plugin call that was being added
+     * @param importDeclarations - The import declarations needed for the plugin
+     * @param reason - The reason why the structure is invalid
+     */
+    static invalidViteConfig(filePath: string, pluginCall: string, importDeclarations: {
+        isNamed: boolean;
+        module: string;
+        identifier: string;
+    }[], reason: string): CodemodException;
+    /**
+     * Creates an exception when tests/bootstrap.ts file is missing
+     *
+     * @param filePath - The path to the missing file
+     * @param pluginCall - The plugin call that was being added
+     * @param importDeclarations - The import declarations needed for the plugin
+     */
+    static missingJapaBootstrap(filePath: string, pluginCall: string, importDeclarations: {
+        isNamed: boolean;
+        module: string;
+        identifier: string;
+    }[]): CodemodException;
+    /**
+     * Creates an exception when tests/bootstrap.ts structure is invalid
+     *
+     * @param filePath - The path to the file being modified
+     * @param pluginCall - The plugin call that was being added
+     * @param importDeclarations - The import declarations needed for the plugin
+     * @param reason - The reason why the structure is invalid
+     */
+    static invalidJapaBootstrap(filePath: string, pluginCall: string, importDeclarations: {
+        isNamed: boolean;
+        module: string;
+        identifier: string;
+    }[], reason: string): CodemodException;
+    /**
+     * Creates an exception when adonisrc.ts file is missing
+     *
+     * @param filePath - The path to the missing file
+     * @param codeToAdd - The code that should be added manually
+     */
+    static missingRcFile(filePath: string, codeToAdd: string): CodemodException;
+    /**
+     * Creates an exception when adonisrc.ts structure is invalid
+     *
+     * @param filePath - The path to the file being modified
+     * @param codeToAdd - The code that should be added manually
+     * @param reason - The reason why the structure is invalid
+     */
+    static invalidRcFile(filePath: string, codeToAdd: string, reason: string): CodemodException;
+    /**
+     * Creates an exception when a file required for transformation is not found.
+     *
+     * @param filePath - The path to the missing file
+     * @param codeToAdd - The code that should be added manually
+     */
+    static E_CODEMOD_FILE_NOT_FOUND(filePath: string, codeToAdd: string): CodemodException;
+    /**
+     * Creates an exception when the file structure doesn't match expected patterns.
+     *
+     * @param message - Description of what structure was expected
+     * @param filePath - The path to the file being modified
+     * @param codeToAdd - The code that should be added manually
+     */
+    static E_CODEMOD_INVALID_STRUCTURE(message: string, filePath: string, codeToAdd: string): CodemodException;
+}

package/build/src/types/code_scanners.d.ts

@@ -70,8 +70,8 @@ export type ScannedValidator = {
  *   pattern: '/users',
  *   tokens: [{ val: '/users', old: '/users', type: 0, end: '' }],
  *   request: {
- *     type: 'Infer<typeof createUserValidator>',
- *     imports: ['import { Infer } from "@vinejs/vine/types"']
+ *     type: 'InferInput<typeof createUserValidator>',
+ *     imports: ['import { InferInput } from "@vinejs/vine/types"']
  *   },
  *   response: {
  *     type: 'ReturnType<UsersController["store"]>',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/assembler",
   "description": "Provides utilities to run AdonisJS development server and build project for production",
-  "version": "8.0.0-next.26",
+  "version": "8.0.0-next.28",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -45,8 +45,8 @@
     "@japa/runner": "^5.0.0",
     "@japa/snapshot": "^2.0.10",
     "@poppinss/ts-exec": "^1.4.1",
-    "@release-it/conventional-changelog": "^10.0.3",
-    "@types/node": "^25.0.2",
+    "@release-it/conventional-changelog": "^10.0.4",
+    "@types/node": "^25.0.3",
     "@types/picomatch": "^4.0.2",
     "@types/pretty-hrtime": "^1.0.3",
     "c8": "^10.1.3",
@@ -54,22 +54,22 @@
     "del-cli": "^7.0.0",
     "eslint": "^9.39.2",
     "hot-hook": "^0.4.1-next.2",
-    "p-event": "^7.0.1",
+    "p-event": "^7.0.2",
     "prettier": "^3.7.4",
-    "release-it": "^19.1.0",
-    "tsdown": "^0.17.4",
+    "release-it": "^19.2.2",
+    "tsdown": "^0.18.4",
     "typedoc": "^0.28.15",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@adonisjs/env": "^7.0.0-next.2",
     "@antfu/install-pkg": "^1.1.0",
-    "@ast-grep/napi": "^0.40.1",
+    "@ast-grep/napi": "^0.40.3",
     "@poppinss/cliui": "^6.6.0",
     "@poppinss/hooks": "^7.3.0",
     "@poppinss/utils": "^7.0.0-next.3",
     "chokidar": "^5.0.0",
-    "dedent": "^1.7.0",
+    "dedent": "^1.7.1",
     "execa": "^9.6.1",
     "fast-glob": "^3.3.3",
     "fdir": "^6.5.0",