@adonisjs/assembler 8.0.0-next.9 → 8.0.0

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
@@ -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,72 @@
-import {
-  findImport,
-  inspectClass,
-  inspectClassMethods,
-  inspectMethodArguments,
-  nodeToPlainText,
-  searchValidatorDirectUsage
-} from "../chunk-TIKQQRMX.js";
-export {
-  findImport,
-  inspectClass,
-  inspectClassMethods,
-  inspectMethodArguments,
-  nodeToPlainText,
-  searchValidatorDirectUsage
-};
+import { parseImports } from "parse-imports";
+async function findImport(code, importReference) {
+	const importIdentifier = importReference.split(".")[0];
+	for (const $import of await parseImports(code, {})) {
+		if (!$import.importClause) continue;
+		if (!$import.moduleSpecifier.value) continue;
+		if ($import.importClause.default === importIdentifier) return {
+			specifier: $import.moduleSpecifier.value,
+			isConstant: $import.moduleSpecifier.isConstant,
+			clause: {
+				type: "default",
+				value: importIdentifier
+			}
+		};
+		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;
+		});
+		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;
+}
+function inspectClass(node) {
+	return node.find({ rule: { kind: "class_declaration" } });
+}
+function inspectClassMethods(node) {
+	return node.findAll({ rule: { kind: "method_definition" } });
+}
+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("");
+}
+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" } });
+	});
+}
+function searchValidatorDirectUsage(node) {
+	return node.findAll({ rule: { pattern: {
+		context: "$$$VALIDATOR.validate($$$)",
+		selector: "call_expression"
+	} } }).flatMap((expression) => {
+		return expression.getMultipleMatches("VALIDATOR");
+	});
+}
+export { findImport, inspectClass, inspectClassMethods, inspectMethodArguments, nodeToPlainText, searchValidatorDirectUsage };

package/build/src/index_generator/main.js

@@ -1,7 +1,29 @@
-import {
-  IndexGenerator
-} from "../../chunk-7XU453QB.js";
-import "../../chunk-PORDZS62.js";
-export {
-  IndexGenerator
+import "../../virtual_file_system-bGeoWsK-.js";
+import { t as IndexGeneratorSource } from "../../source-dVeugJ0e.js";
+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();
+		if (sources.length) this.#cliLogger.info(`codegen: created ${sources.length} file(s)`);
+	}
 };
+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;
 }

package/build/src/test_runner.d.ts

@@ -1,4 +1,3 @@
-import type tsStatic from 'typescript';
 import type { TestRunnerOptions } from './types/common.ts';
 /**
  * Exposes the API to run Japa tests and optionally watch for file
@@ -33,6 +32,7 @@ export declare class TestRunner {
         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;
@@ -42,6 +42,7 @@ export declare class TestRunner {
             info: string;
             warning: string;
             squareSmallFilled: string;
+            borderVertical: string;
         };
         sticker: () => import("@poppinss/cliui").Instructions;
         instructions: () => import("@poppinss/cliui").Instructions;
@@ -111,7 +112,7 @@ export declare class TestRunner {
      * @param ts - TypeScript module reference for parsing configuration
      * @param options - Watch options including polling mode for file system monitoring
      */
-    runAndWatch(ts: typeof tsStatic, options?: {
+    runAndWatch(options?: {
         poll: boolean;
     }): Promise<void>;
 }

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"]>',
@@ -174,12 +174,12 @@ export type RoutesListItem = {
     domain: string;
     /** HTTP methods accepted by this route */
     methods: string[];
-    /** Controller reference information (if controller-based route) */
-    controllerReference?: {
-        /** Dynamic import expression for the controller */
-        importExpression: string;
-        /** Specific controller method to call */
-        method?: string;
+    /** Handler information for controller-based routes */
+    handler?: {
+        /** The method name to be called on the controller */
+        method: string;
+        /** Dynamic import expression that loads the controller module */
+        importExpression: string | null;
     };
     /** Parsed route tokens for URI construction */
     tokens: {
@@ -189,6 +189,27 @@ export type RoutesListItem = {
         end: string;
     }[];
 };
+/**
+ * A filter function to exclude routes from being processed by the routes scanner.
+ * Return false to filter out (exclude) the route, or true to include it.
+ *
+ * @example
+ * const filterFn: RoutesScannerFilterFn = (route) => {
+ *   // Exclude all admin routes
+ *   if (route.pattern.startsWith('/admin')) {
+ *     return false
+ *   }
+ *
+ *   // Exclude health check routes
+ *   if (route.name === 'health.check') {
+ *     return false
+ *   }
+ *
+ *   // Include all other routes
+ *   return true
+ * }
+ */
+export type RoutesScannerFilterFn = (route: RoutesListItem) => boolean;
 /**
  * Configuration rules accepted by the routes scanner to customize
  * the scanning behavior and override type inference.
@@ -211,11 +232,6 @@ export type RoutesListItem = {
  * }
  */
 export type RoutesScannerRules = {
-    /**
-     * An array of route names or controller+method paths to skip from processing.
-     * Useful for excluding routes that don't need type generation.
-     */
-    skip: string[];
     /**
      * Define custom response types for specific routes by their name
      * or controller+method path. Overrides automatic type inference.