@adonisjs/assembler 8.0.0-next.9 → 8.0.1

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

@@ -82,12 +82,38 @@ export declare class RcFileTransformer {
     addSuite(suiteName: string, files: string | string[], timeout?: number): this;
     /**
      * Add a new assembler hook
+     * The format `thunk` write `() => import(path)`.
      *
      * @param type - The type of hook to add
-     * @param path - The path to the hook file
+     * @param value - The path to the hook file or value to write
+     * @param raw - Wether to write a thunk import or as raw value
      * @returns This RcFileTransformer instance for method chaining
      */
-    addAssemblerHook(type: keyof Exclude<AssemblerRcFile['hooks'], undefined>, path: string): this;
+    addAssemblerHook(type: keyof Exclude<AssemblerRcFile['hooks'], undefined>, value: string, raw?: boolean): this;
+    /**
+     * Add a named import
+     *
+     * @param specifier - The module specifier to import
+     * @param names - Names to import from the module
+     * @returns This RcFileTransformer instance for method chaining
+     */
+    addNamedImport(specifier: string, names: string[]): this;
+    /**
+     * Add a default import
+     *
+     * @param specifier - The module specifier to import
+     * @param name - Name of the default import
+     * @returns This RcFileTransformer instance for method chaining
+     */
+    addDefaultImport(specifier: string, name: 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/debug.d.ts

@@ -10,5 +10,5 @@
  * // NODE_DEBUG=adonisjs:assembler node ace serve
  * debug('Starting development server...')
  */
-declare const _default: import("util").DebugLogger;
+declare const _default: import("node:util").DebugLogger;
 export default _default;

package/build/src/dev_server.d.ts

@@ -1,15 +1,16 @@
-import type tsStatic from 'typescript';
 import type { DevServerOptions } from './types/common.ts';
 /**
- * Exposes the API to start the development server in HMR, watch or static mode.
+ * Exposes the API to start the development server in HMR, watch or static mode
  *
  * In HMR mode, the DevServer will exec the "bin/server.ts" file and let hot-hook
  * manage the changes using hot module reloading.
  *
- * In watch mode, the DevServer will start an internal watcher and restarts the after
- * every file change. The files must be part of the TypeScript project (via tsconfig.json),
+ * In watch mode, the DevServer will start an internal watcher and restarts the server
+ * after every file change. The files must be part of the TypeScript project (via tsconfig.json),
  * or registered as metaFiles.
  *
+ * In static mode, the server runs without file watching or hot reloading.
+ *
  * @example
  * const devServer = new DevServer(cwd, { hmr: true, hooks: [] })
  * await devServer.start(ts)
@@ -24,6 +25,7 @@ export declare class DevServer {
         logger: import("@poppinss/cliui").Logger;
         table: (tableOptions?: Partial<import("@poppinss/cliui/types").TableOptions>) => import("@poppinss/cliui").Table;
         tasks: (tasksOptions?: Partial<import("@poppinss/cliui/types").TaskManagerOptions>) => import("@poppinss/cliui").TaskManager;
+        steps: () => import("@poppinss/cliui").Steps;
         icons: {
             tick: string;
             cross: string;
@@ -33,6 +35,7 @@ export declare class DevServer {
             info: string;
             warning: string;
             squareSmallFilled: string;
+            borderVertical: string;
         };
         sticker: () => import("@poppinss/cliui").Instructions;
         instructions: () => import("@poppinss/cliui").Instructions;
@@ -41,7 +44,12 @@ export declare class DevServer {
         useColors(colorsToUse: import("@poppinss/colors/types").Colors): void;
     };
     /**
-     * The mode in which the DevServer is running.
+     * The mode in which the DevServer is running
+     *
+     * Returns the current operating mode of the development server:
+     * - 'hmr': Hot Module Reloading enabled
+     * - 'watch': File system watching with full restarts
+     * - 'static': No file watching or hot reloading
      */
     get mode(): "hmr" | "watch" | "static";
     /**
@@ -68,36 +76,76 @@ export declare class DevServer {
      */
     constructor(cwd: URL, options: DevServerOptions);
     /**
-     * Add listener to get notified when dev server is closed
+     * Adds listener to get notified when dev server is closed
+     *
+     * Registers a callback function that will be invoked when the development
+     * server's child process exits. The callback receives the exit code.
      *
      * @param callback - Function to call when dev server closes
      * @returns This DevServer instance for method chaining
+     *
+     * @example
+     * devServer.onClose((exitCode) => {
+     *   console.log(`Server closed with exit code: ${exitCode}`)
+     * })
      */
     onClose(callback: (exitCode: number) => any): this;
     /**
-     * Add listener to get notified when dev server encounters an error
+     * Adds listener to get notified when dev server encounters an error
+     *
+     * Registers a callback function that will be invoked when the development
+     * server's child process encounters an error or fails to start.
      *
      * @param callback - Function to call when dev server encounters an error
      * @returns This DevServer instance for method chaining
+     *
+     * @example
+     * devServer.onError((error) => {
+     *   console.error('Dev server error:', error.message)
+     * })
      */
     onError(callback: (error: any) => any): this;
     /**
-     * Close watchers and the running child process
+     * Closes watchers and terminates the running child process
+     *
+     * Cleans up keyboard shortcuts, stops file system watchers, and kills
+     * the HTTP server child process. This should be called when shutting down
+     * the development server.
+     *
+     * @example
+     * await devServer.close()
      */
     close(): Promise<void>;
     /**
-     * Start the development server in static or HMR mode
+     * Starts the development server in static or HMR mode
+     *
+     * Initializes the server and starts the HTTP server. The mode is determined
+     * by the `hmr` option in DevServerOptions. In HMR mode, hot-hook is configured
+     * to enable hot module reloading.
      *
      * @param ts - TypeScript module reference
+     *
+     * @example
+     * const devServer = new DevServer(cwd, { hmr: true, hooks: [] })
+     * await devServer.start(ts)
      */
-    start(ts: typeof tsStatic): Promise<void>;
+    start(): Promise<void>;
     /**
-     * Start the development server in watch mode and restart on file changes
+     * Starts the development server in watch mode and restarts on file changes
+     *
+     * Initializes the server, starts the HTTP server, and sets up a file system
+     * watcher that monitors for changes. When files are added, modified, or deleted,
+     * the server automatically restarts. The watcher respects TypeScript project
+     * configuration and metaFiles settings.
      *
      * @param ts - TypeScript module reference
      * @param options - Watch options including polling mode
+     *
+     * @example
+     * const devServer = new DevServer(cwd, { hooks: [] })
+     * await devServer.startAndWatch(ts, { poll: false })
      */
-    startAndWatch(ts: typeof tsStatic, options?: {
+    startAndWatch(options?: {
         poll: boolean;
     }): Promise<void>;
 }

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/file_buffer.d.ts

@@ -29,6 +29,17 @@ export declare class FileBuffer {
      * @returns The number of lines in the buffer
      */
     get size(): number;
+    /**
+     * Enable or disable end-of-line character at the end of output
+     *
+     * @param enabled - Whether to add EOL character
+     * @returns This FileBuffer instance for method chaining
+     *
+     * @example
+     * const buffer = new FileBuffer()
+     * buffer.eol(true).writeLine('Hello').flush() // 'Hello\n\n'
+     */
+    eol(enabled: boolean): this;
     /**
      * Write a new line to the output with current indentation
      *
@@ -55,6 +66,14 @@ export declare class FileBuffer {
      * @returns This FileBuffer instance for method chaining
      */
     dedent(): this;
+    /**
+     * Convert the buffer to a string representation
+     *
+     * @example
+     * const buffer = new FileBuffer()
+     * buffer.writeLine('Hello')
+     * console.log(buffer.toString())
+     */
     toString(): string;
     /**
      * Return template as a string, joining all buffer lines

package/build/src/file_system.d.ts

@@ -1,4 +1,4 @@
-import type tsStatic from 'typescript';
+import { type TsConfigResult } from 'get-tsconfig';
 import { type InspectedFile, type AssemblerRcFile } from './types/common.ts';
 /**
  * Exposes an intutive API to run actions when different kind of files
@@ -37,7 +37,7 @@ export declare class FileSystem {
      *
      * Following patterns are always ignored
      *
-     * '.git/**', 'coverage/**', '.github/**'
+     * '.git/**', 'coverage/**', '.github/**', '.adonisjs/**', 'tmp/**', 'storage/**', 'build/**'
      */
     get excludes(): string[];
     /**
@@ -83,7 +83,7 @@ export declare class FileSystem {
      * @param tsConfig - Parsed TypeScript configuration
      * @param rcFile - AdonisJS RC file configuration
      */
-    constructor(cwd: string, tsConfig: tsStatic.ParsedCommandLine, rcFile: AssemblerRcFile);
+    constructor(cwd: string, tsConfig: TsConfigResult, rcFile: AssemblerRcFile);
     /**
      * Returns true if the file should be watched. Chokidar sends
      * absolute unix paths to the ignored callback.

package/build/src/helpers.js

@@ -1,16 +1,205 @@
-import {
-  findImport,
-  inspectClass,
-  inspectClassMethods,
-  inspectMethodArguments,
-  nodeToPlainText,
-  searchValidatorDirectUsage
-} from "../chunk-TIKQQRMX.js";
-export {
-  findImport,
-  inspectClass,
-  inspectClassMethods,
-  inspectMethodArguments,
-  nodeToPlainText,
-  searchValidatorDirectUsage
-};
+import "../chunk-DF48asd8.js";
+import { parseImports } from "parse-imports";
+//#region src/helpers.ts
+/**
+* Finds an import reference inside a code snippet by analyzing the import statements
+* and matching against the provided import reference identifier.
+*
+* The function searches through all import statements in the code and matches
+* against default, namespace, or named imports based on the import reference.
+*
+* @param code - The code snippet to search for imports
+* @param importReference - The import reference identifier to find (can include dot notation)
+* @returns Promise that resolves to an Import object or null if not found
+*
+* @example
+* const importInfo = await findImport(code, 'validateUser')
+* if (importInfo) {
+*   console.log(importInfo.specifier) // '@/validators/user'
+* }
+*/
+async function findImport(code, importReference) {
+	const importIdentifier = importReference.split(".")[0];
+	for (const $import of await parseImports(code, {})) {
+		/**
+		* An import without any clause
+		*/
+		if (!$import.importClause) continue;
+		/**
+		* An import without any clause
+		*/
+		if (!$import.moduleSpecifier.value) continue;
+		/**
+		* Import identifier matches a default import
+		*/
+		if ($import.importClause.default === importIdentifier) return {
+			specifier: $import.moduleSpecifier.value,
+			isConstant: $import.moduleSpecifier.isConstant,
+			clause: {
+				type: "default",
+				value: importIdentifier
+			}
+		};
+		/**
+		* Import identifier matches a namespace import
+		*/
+		if ($import.importClause.namespace === importIdentifier) return {
+			specifier: $import.moduleSpecifier.value,
+			isConstant: $import.moduleSpecifier.isConstant,
+			clause: {
+				type: "namespace",
+				value: importIdentifier
+			}
+		};
+		const namedImport = $import.importClause.named.find(({ binding }) => {
+			return binding === importIdentifier;
+		});
+		/**
+		* Import identifier matches a named import
+		*/
+		if (namedImport) return {
+			specifier: $import.moduleSpecifier.value,
+			isConstant: $import.moduleSpecifier.isConstant,
+			clause: {
+				type: "named",
+				value: namedImport.specifier,
+				...namedImport.binding !== namedImport.specifier ? { alias: namedImport.binding } : {}
+			}
+		};
+	}
+	return null;
+}
+/**
+* Returns a node that represents a TypeScript class or null
+* when unable to find the class.
+*
+* This function searches for class declarations within the provided AST node
+* using ast-grep's pattern matching capabilities.
+*
+* @param node - The AST node to search within for class declarations
+* @returns The SgNode representing the class or null if not found
+*
+* @example
+* const classNode = inspectClass(rootNode)
+* if (classNode) {
+*   console.log('Found class:', classNode.text())
+* }
+*/
+function inspectClass(node) {
+	return node.find({ rule: { kind: "class_declaration" } });
+}
+/**
+* Returns an array of SgNodes for class methods. The input node
+* must represent a class.
+*
+* This function finds all method definitions within a class node,
+* including both regular methods and static methods.
+*
+* @param node - The AST node representing a class to search for methods
+* @returns Array of SgNodes representing method definitions within the class
+*
+* @example
+* const classNode = inspectClass(rootNode)
+* if (classNode) {
+*   const methods = inspectClassMethods(classNode)
+*   methods.forEach(method => console.log('Method:', method.text()))
+* }
+*/
+function inspectClassMethods(node) {
+	return node.findAll({ rule: { kind: "method_definition" } });
+}
+/**
+* Converts an SgNode to plain text by removing whitespaces,
+* indentation and comments in between. Tested with the following
+* children nodes only.
+*
+* - MemberExpression
+* - Identifier
+*
+* This function recursively traverses the AST node and extracts only
+* the meaningful text content without any formatting or whitespace.
+*
+* @param node - The AST node to convert to plain text
+* @returns String representation of the node without formatting
+*
+* @example
+* const memberExpression = node.find({ rule: { kind: 'member_expression' } })
+* const plainText = nodeToPlainText(memberExpression)
+* console.log(plainText) // 'user.validate'
+*/
+function nodeToPlainText(node) {
+	let out = [];
+	function toText(one) {
+		const children = one.children();
+		if (!children.length) out.push(one.text());
+		else children.forEach((child) => toText(child));
+	}
+	toText(node);
+	return out.join("");
+}
+/**
+* Inspects arguments for one or more method calls. If you want to
+* scope the search within a specific context, then make sure to
+* first narrow down the AST and pass a specific SgNode.
+*
+* For example: In case of validators, we will first find the Controller
+* method for which we want the validation method calls.
+*
+* This function searches for call expressions that match the provided method
+* names and returns their argument nodes for further analysis.
+*
+* @param node - The AST node to search within for method calls
+* @param methodCalls - Array of method call names to search for (supports dot notation)
+* @returns Array of SgNodes representing the arguments of matching method calls
+*
+* @example
+* const controllerMethod = classNode.find({ rule: { kind: 'method_definition' } })
+* const validatorArgs = inspectMethodArguments(controllerMethod, ['validate', 'request.validate'])
+* validatorArgs.forEach(arg => console.log('Validator argument:', arg.text()))
+*/
+function inspectMethodArguments(node, methodCalls) {
+	return node.findAll({ rule: { any: methodCalls.map((methodCall) => {
+		return { pattern: {
+			context: `${methodCall}($$$ARGUMENTS)`,
+			selector: "call_expression"
+		} };
+	}) } }).flatMap((matchingExpression) => {
+		return matchingExpression.findAll({ rule: { kind: "arguments" } });
+	});
+}
+/**
+* Inspect the validator direct usage code snippets. A member expression
+* calling the ".validate" method is considered as direct usage of
+* the validator.
+*
+* This function specifically looks for patterns where validators are called
+* directly with the `.validate()` method, which is common in AdonisJS applications.
+*
+* @param node - The AST node to search within for validator direct usage
+* @returns Array of SgNodes representing validator expressions that call validate method
+*
+* @example
+* const methodNode = classNode.find({ rule: { kind: 'method_definition' } })
+* const validators = searchValidatorDirectUsage(methodNode)
+* validators.forEach(validator => {
+*   console.log('Direct validator usage:', nodeToPlainText(validator))
+* })
+*/
+function searchValidatorDirectUsage(node) {
+	return node.findAll({ rule: { pattern: {
+		context: "$$$VALIDATOR.validate($$$)",
+		selector: "call_expression"
+	} } }).flatMap((expression) => {
+		/**
+		* Since we capture all "$$$.validate" calls, the first node
+		* within the call expression will be a member expression
+		* and its property identifier will be "validate".
+		*
+		* What we need is the text of this member expression without the
+		* comments
+		*/
+		return expression.getMultipleMatches("VALIDATOR");
+	});
+}
+//#endregion
+export { findImport, inspectClass, inspectClassMethods, inspectMethodArguments, nodeToPlainText, searchValidatorDirectUsage };

package/build/src/index_generator/main.js

@@ -1,7 +1,4 @@
-import {
-  IndexGenerator
-} from "../../chunk-7XU453QB.js";
-import "../../chunk-PORDZS62.js";
-export {
-  IndexGenerator
-};
+import "../../chunk-DF48asd8.js";
+import "../../virtual_file_system-dzfXNwEp.js";
+import { t as IndexGenerator } from "../../main-INOi9swJ.js";
+export { IndexGenerator };

package/build/src/paths_resolver.d.ts

@@ -13,6 +13,7 @@
  */
 export declare class PathsResolver {
     #private;
+    constructor(appRoot: string);
     /**
      * Define a custom resolver that resolves a path
      *
@@ -36,5 +37,5 @@ export declare class PathsResolver {
      * const path = resolver.resolve('#app/models/user')
      * const path2 = resolver.resolve('@/utils/helper')
      */
-    resolve(specifier: string): string;
+    resolve(specifier: string, rewriteAliasImportExtension?: boolean): string;
 }