@adonisjs/assembler 8.0.0-next.1 → 8.0.0-next.3

package/README.md

@@ -50,17 +50,7 @@ const devServer = new DevServer(appRoot, {
       pattern: 'resources/views/**/*.edge',
       reloadServer: false,
     }
-  ],
-
-  /**
-   * The assets bundler process to start
-   */
-  assets: {
-    enabled: true,
-    name: 'vite',
-    cmd: 'vite',
-    args: []
-  }
+  ]
 })
 
 devServer.onError((error) => {
@@ -87,9 +77,6 @@ await devServer.start()
 ## Test runner
 The `TestRunner` is used to execute the `bin/test.ts` file of your AdonisJS application. Like the `DevServer`, the `TestRunner` allows you to watch for file changes and re-run the tests. The following steps are taken to re-run tests in watch mode.
 
-> [!NOTE]  
-> Read [Using a file watcher](#using-a-file-watcher) section to understand which files are watched by the file watcher.
-
 - If the changed file is a test file, only tests for that file will be re-run.
 - Otherwise, all tests will re-run with respect to the initial filters applied when running the `node ace test` command.
 
@@ -176,17 +163,6 @@ const bundler = new Bundler(appRoot, ts, {
       reloadServer: false,
     }
   ],
-
-  /**
-   * The assets bundler to use to bundle the frontend
-   * assets
-   */
-  assets: {
-    enabled: true,
-    name: 'vite',
-    cmd: 'vite',
-    args: ['build']
-  }
 })
 ```
 
@@ -444,6 +420,85 @@ export const policies = {
 }
 ```
 
+### makeEntityIndex
+The method is used to create an index file for a collection of entities discovered from one or more root folders. We use this method to create an index file for controllers or generate types for Inertia pages.
+
+```ts
+const transformer = new CodeTransformer(appRoot)
+
+const output = await transformer.makeEntityIndex({
+  source: 'app/controllers',
+  importAlias: '#controllers'
+}, {
+  destination: '.adonisjs/backend/controllers',
+  exportName: 'controllers'
+})
+
+/**
+  export const controllers = {
+    SignupController: () => import('#controllers/auth/signup_controller'),
+    PostsController: () => import('#controllers/posts_controller'),
+    HomePage: () => import('#controllers/public/home_page'),
+    UserPostsController: () => import('#controllers/user/posts_controller'),
+  }
+ */
+```
+
+If you would like to remove the `Controller` suffix from the key (which we do in our official generator), then you can specify the `removeNameSuffix` option.
+
+```ts
+const output = await transformer.makeEntityIndex({
+  source: 'app/controllers',
+  importAlias: '#controllers'
+}, {
+  destination: '.adonisjs/backend/controllers',
+  exportName: 'controllers',
+  removeNameSuffix: 'controller'
+})
+```
+
+For more advanced use-cases, you can specify the `computeBaseName` method to self compute the key name for the collection.
+
+```ts
+import StringBuilder from '@poppinss/utils/string_builder'
+
+const output = await transformer.makeEntityIndex({
+  source: 'app/controllers',
+  importAlias: '#controllers'
+}, {
+  destination: '.adonisjs/backend/controllers',
+  exportName: 'controllers',
+  computeBaseName(filePath, sourcePath) {
+    const baseName = relative(sourcePath, filePath)
+    return new StringBuilder(baseName).toUnixSlash().removeExtension().removeSuffix('Controller').toString()
+  },
+})
+```
+
+#### Controlling the output
+The output is an object with key-value pair in which the value is a lazily imported module. However, you can customize the output to generate a TypeScript type using the `computeOutput` method.
+
+```ts
+const output = await transformer.makeEntityIndex(
+  { source: './inertia/pages', allowedExtensions: ['.tsx'] },
+  {
+    destination: outputPath,
+    computeOutput(entries) {
+      return entries
+        .reduce<string[]>(
+          (result, entry) => {
+            result.push(`${entry.name}: typeof import('${entry.importPath}')`)
+            return result
+          },
+          [`declare module '@adonisjs/inertia' {`, 'export interface Pages {']
+        )
+        .concat('}', '}')
+        .join('\n')
+    },
+  }
+)
+```
+
 ## Contributing
 One of the primary goals of AdonisJS is to have a vibrant community of users and contributors who believe in the framework's principles.
 

package/build/index.js

@@ -560,6 +560,104 @@ var FileSystem = class {
   }
 };
 
+// src/shortcuts_manager.ts
+var ShortcutsManager = class {
+  #logger;
+  #callbacks;
+  #serverUrl;
+  #keyPressHandler;
+  #shortcuts = [
+    {
+      key: "r",
+      description: "restart server",
+      handler: () => {
+        this.#logger.log("");
+        this.#logger.info("Manual restart triggered...");
+        this.#callbacks.onRestart();
+      }
+    },
+    {
+      key: "c",
+      description: "clear console",
+      handler: () => {
+        this.#callbacks.onClear();
+        this.#logger.info("Console cleared");
+      }
+    },
+    {
+      key: "o",
+      description: "open in browser",
+      handler: () => this.#handleOpenBrowser()
+    },
+    {
+      key: "h",
+      description: "show this help",
+      handler: () => this.showHelp()
+    }
+  ];
+  constructor(options) {
+    this.#logger = options.logger;
+    this.#callbacks = options.callbacks;
+  }
+  /**
+   * Set server url for opening in browser
+   */
+  setServerUrl(url) {
+    this.#serverUrl = url;
+  }
+  /**
+   * Initialize keyboard shortcuts
+   */
+  setup() {
+    if (!process.stdin.isTTY) {
+      return;
+    }
+    process.stdin.setRawMode(true);
+    this.#keyPressHandler = (data) => this.#handleKeyPress(data.toString());
+    process.stdin.on("data", this.#keyPressHandler);
+  }
+  /**
+   * Handle key press events
+   */
+  #handleKeyPress(key) {
+    if (key === "" || key === "") {
+      return this.#callbacks.onQuit();
+    }
+    const shortcut = this.#shortcuts.find((s) => s.key === key);
+    if (shortcut) {
+      shortcut.handler();
+    }
+  }
+  /**
+   * Handle opening browser
+   */
+  async #handleOpenBrowser() {
+    this.#logger.log("");
+    this.#logger.info(`Opening ${this.#serverUrl}...`);
+    const { default: open } = await import("open");
+    open(this.#serverUrl);
+  }
+  /**
+   * Show available keyboard shortcuts
+   */
+  showHelp() {
+    this.#logger.log("");
+    this.#logger.log("Available shortcuts:");
+    this.#shortcuts.forEach(({ key, description }) => this.#logger.log(`\xB7 ${key}: ${description}`));
+  }
+  /**
+   * Cleanup keyboard shortcuts
+   */
+  cleanup() {
+    if (!process.stdin.isTTY) {
+      return;
+    }
+    process.stdin.setRawMode(false);
+    process.stdin.removeListener("data", this.#keyPressHandler);
+    this.#keyPressHandler = void 0;
+  }
+};
+
 // src/dev_server.ts
 var DevServer = class {
   constructor(cwd, options) {
@@ -594,6 +692,10 @@ var DevServer = class {
    * Reference to the child process
    */
   #httpServer;
+  /**
+   * Keyboard shortcuts manager
+   */
+  #shortcutsManager;
   /**
    * Filesystem is used to decide which files to watch or entertain when
    * using hot-hook
@@ -614,6 +716,26 @@ var DevServer = class {
     }
     await this.#startHTTPServer(this.#stickyPort);
   }, "restartHTTPServer");
+  /**
+   * Sets up keyboard shortcuts
+   */
+  #setupKeyboardShortcuts() {
+    this.#shortcutsManager = new ShortcutsManager({
+      logger: this.ui.logger,
+      callbacks: {
+        onRestart: () => this.#restartHTTPServer(),
+        onClear: () => this.#clearScreen(),
+        onQuit: () => this.close()
+      }
+    });
+    this.#shortcutsManager.setup();
+  }
+  /**
+   * Cleanup keyboard shortcuts
+   */
+  #cleanupKeyboardShortcuts() {
+    this.#shortcutsManager?.cleanup();
+  }
   /**
    * CLI UI to log colorful messages
    */
@@ -640,10 +762,13 @@ var DevServer = class {
    */
   async #postServerReady(message) {
     const host = message.host === "0.0.0.0" ? "127.0.0.1" : message.host;
-    const displayMessage = this.ui.sticker().add(`Server address: ${this.ui.colors.cyan(`http://${host}:${message.port}`)}`).add(`Mode: ${this.ui.colors.cyan(this.mode)}`);
+    const serverUrl = `http://${host}:${message.port}`;
+    this.#shortcutsManager?.setServerUrl(serverUrl);
+    const displayMessage = this.ui.sticker().add(`Server address: ${this.ui.colors.cyan(serverUrl)}`).add(`Mode: ${this.ui.colors.cyan(this.mode)}`);
     if (message.duration) {
       displayMessage.add(`Ready in: ${this.ui.colors.cyan(prettyHrtime(message.duration))}`);
     }
+    displayMessage.add(`Press ${this.ui.colors.dim("h")} to show help`);
     try {
       await this.#hooks.runner("devServerStarted").run(this, displayMessage);
     } catch (error) {
@@ -807,6 +932,7 @@ var DevServer = class {
    * Close watchers and the running child process
    */
   async close() {
+    this.#cleanupKeyboardShortcuts();
     await this.#watcher?.close();
     if (this.#httpServer) {
       this.#httpServer.removeAllListeners();
@@ -842,6 +968,7 @@ var DevServer = class {
       };
     }
     this.#clearScreen();
+    this.#setupKeyboardShortcuts();
     this.ui.logger.info("starting HTTP server...");
     await this.#startHTTPServer(this.#stickyPort);
   }
@@ -865,6 +992,7 @@ var DevServer = class {
     ]);
     this.#registerServerRestartHooks();
     this.#clearScreen();
+    this.#setupKeyboardShortcuts();
     this.ui.logger.info("starting HTTP server...");
     await this.#startHTTPServer(this.#stickyPort);
     this.#watcher = watch({

package/build/src/ast_file_system.d.ts

@@ -0,0 +1,17 @@
+import { type SgNode } from '@ast-grep/napi';
+/**
+ * An abstraction around converting files to an AST and caching
+ * them forever. The cache could be cleared manually.
+ */
+export declare class AstFileSystem {
+    #private;
+    /**
+     * Returns the file contents as AST-grep node and caches it
+     * forever.
+     */
+    get(filePath: string): Promise<SgNode>;
+    /**
+     * Clear AST cache for a single file or all the files
+     */
+    clear(filePath?: string): void;
+}

package/build/src/code_scanners/routes_scanner/main.d.ts

@@ -0,0 +1,79 @@
+import { type AsyncOrSync } from '@poppinss/utils/types';
+import { PathsResolver } from '../../paths_resolver.ts';
+import { AstFileSystem } from '../../ast_file_system.ts';
+import { type ScannedRoute, type RoutesListItem, type ScannedController, type RoutesScannerRules } from '../../types/code_scanners.ts';
+export declare class RoutesScanner {
+    #private;
+    /**
+     * CLI UI to log colorful messages
+     */
+    ui: {
+        colors: import("@poppinss/colors/types").Colors;
+        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;
+        icons: {
+            tick: string;
+            cross: string;
+            bullet: string;
+            nodejs: string;
+            pointer: string;
+            info: string;
+            warning: string;
+            squareSmallFilled: string;
+        };
+        sticker: () => import("@poppinss/cliui").Instructions;
+        instructions: () => import("@poppinss/cliui").Instructions;
+        switchMode(modeToUse: "raw" | "silent" | "normal"): void;
+        useRenderer(rendererToUse: import("@poppinss/cliui/types").RendererContract): void;
+        useColors(colorsToUse: import("@poppinss/colors/types").Colors): void;
+    };
+    /**
+     * The paths resolver is used to convert subpath and package
+     * imports to absolute paths
+     */
+    pathsResolver: PathsResolver;
+    /**
+     * The AstFileSystem is used to convert files to AST-grep nodes.
+     * The AST is cached to speed up the performance.
+     */
+    astFileSystem: AstFileSystem;
+    /**
+     * The rules to apply when scanning routes
+     */
+    rules: RoutesScannerRules;
+    constructor(appRoot: string, rulesCollection: RoutesScannerRules[]);
+    /**
+     * Register a callback to self compute the response types for
+     * a given route. The callback will be executed for all
+     * the routes and you must return undefined to fallback
+     * to the default behavior of detecting types
+     */
+    defineResponse(callback: (route: ScannedRoute, controller: ScannedController, scanner: RoutesScanner) => AsyncOrSync<ScannedRoute['response']>): this;
+    /**
+     * Register a callback to self compute the request types for
+     * a given route. The callback will be executed for all
+     * the routes and you must return undefined to fallback
+     * to the default behavior of detecting types
+     */
+    defineRequest(callback: (route: ScannedRoute, controller: ScannedController, scanner: RoutesScanner) => AsyncOrSync<ScannedRoute['request']>): this;
+    /**
+     * Register a callback to extract validators from the route
+     * controller.
+     */
+    extractValidators(callback: (route: ScannedRoute, controller: ScannedController, scanner: RoutesScanner) => AsyncOrSync<ScannedRoute['validators']>): this;
+    /**
+     * Returns the scanned routes
+     */
+    getScannedRoutes(): ScannedRoute[];
+    /**
+     * Invalidating a controller will trigger computing the validators,
+     * request types and the response types.
+     */
+    invalidate(controllerPath: string): Promise<void>;
+    /**
+     * Scans an array of Route list items and fetches their validators,
+     * controllers, and request/response types.
+     */
+    scan(routes: RoutesListItem[]): Promise<void>;
+}

package/build/src/code_scanners/routes_scanner/validator_extractor.d.ts

@@ -0,0 +1,18 @@
+import { type AstFileSystem } from '../../ast_file_system.ts';
+import { type ScannedController, type ScannedRoute } from '../../types/code_scanners.ts';
+/**
+ * Extracts the VineJS validator usage from within a controller
+ * method. The following syntaxes are supported.
+ *
+ * - `request.validateUsing(validatorReference)`
+ * - `vine.validate(validatorReference)`
+ * - `validatorReference.validate(request.all())`
+ *
+ * - `request.validateUsing(ControllerReference.validator)`
+ * - `vine.validate(ControllerReference.validator)`
+ * - `ControllerReference.validator.validate(request.all())`
+ *
+ * The app root is needed to create relative validator imports in case
+ * a relative import was used within the controller file.
+ */
+export declare function extractValidators(appRoot: string, astFileSystem: AstFileSystem, controller: ScannedController): Promise<ScannedRoute['validators']>;

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

@@ -67,8 +67,8 @@ export declare class CodeTransformer {
      *
      * ```ts
      * export const controllers = {
-     *   Login: () => import('#controllers/login_controller'),
-     *   Login: () => import('#controllers/login_controller'),
+     *   LoginController: () => import('#controllers/login_controller'),
+     *   LogoutController: () => import('#controllers/logout_controller'),
      * }
      * ```
      *
@@ -79,10 +79,15 @@ export declare class CodeTransformer {
     makeEntityIndex(input: OneOrMore<{
         source: string;
         importAlias?: string;
+        allowedExtensions?: string[];
     }>, output: {
         destination: string;
         exportName?: string;
-        transformName?: (name: string) => string;
-        transformImport?: (modulePath: string) => string;
+        removeNameSuffix?: string;
+        computeBaseName?: (filePath: string, sourcePath: string) => string;
+        computeOutput?: (entries: {
+            name: string;
+            importPath: string;
+        }[]) => string;
     }): Promise<void>;
 }

package/build/src/code_transformer/main.js

@@ -9,7 +9,7 @@ import { isScriptFile } from "@poppinss/utils";
 import { fsReadAll } from "@poppinss/utils/fs";
 import { mkdir, writeFile } from "fs/promises";
 import StringBuilder from "@poppinss/utils/string_builder";
-import { basename, dirname, join, relative } from "path";
+import { basename, dirname, extname, join, relative } from "path";
 import { installPackage, detectPackageManager } from "@antfu/install-pkg";
 import {
   Node as Node2,
@@ -539,8 +539,8 @@ var CodeTransformer = class {
    *
    * ```ts
    * export const controllers = {
-   *   Login: () => import('#controllers/login_controller'),
-   *   Login: () => import('#controllers/login_controller'),
+   *   LoginController: () => import('#controllers/login_controller'),
+   *   LogoutController: () => import('#controllers/logout_controller'),
    * }
    * ```
    *
@@ -560,32 +560,51 @@ var CodeTransformer = class {
       inputs
     );
     const entries = await Promise.all(
-      inputs.map(async ({ source, importAlias }) => {
+      inputs.map(async ({ source, importAlias, allowedExtensions }) => {
         const sourcePath = join(this.#cwdPath, source);
         const filesList = await fsReadAll(sourcePath, {
-          filter: isScriptFile,
+          filter: (filePath) => {
+            if (allowedExtensions) {
+              const ext = extname(filePath);
+              return allowedExtensions.includes(ext);
+            }
+            return isScriptFile(filePath);
+          },
           pathType: "absolute"
         });
+        const knownBaseNames = /* @__PURE__ */ new Set();
         return filesList.map((filePath) => {
-          const name = new StringBuilder(string.toUnixSlash(relative(sourcePath, filePath))).removeExtension().pascalCase().toString();
-          const importPath = importAlias ? `${importAlias}/${new StringBuilder(string.toUnixSlash(relative(sourcePath, filePath))).removeExtension().toString()}` : string.toUnixSlash(relative(outputDir, filePath));
+          let baseName = basename(filePath);
+          if (output.computeBaseName) {
+            baseName = output.computeBaseName?.(filePath, sourcePath);
+          } else {
+            if (knownBaseNames.has(baseName)) {
+              baseName = string.toUnixSlash(relative(sourcePath, filePath));
+            }
+            knownBaseNames.add(baseName);
+          }
+          const name = new StringBuilder(baseName).removeExtension().removeSuffix(output.removeNameSuffix ?? "").pascalCase().toString();
+          const baseImportPath = importAlias ? string.toUnixSlash(relative(sourcePath, filePath)) : string.toUnixSlash(relative(outputDir, filePath));
+          const importPath = importAlias ? `${importAlias}/${new StringBuilder(baseImportPath).removeExtension().toString()}` : baseImportPath;
           return {
-            name: output.transformName?.(name) ?? name,
-            importPath: output.transformImport?.(importPath) ?? importPath
+            name,
+            importPath
           };
         });
       })
     );
-    const outputContents = entries.flat(2).reduce(
-      (result, entry) => {
-        debug_default('adding "%O" to the index', entry);
-        result.push(`  ${entry.name}: () => import('${entry.importPath}'),`);
-        return result;
-      },
-      [`export const ${exportName} = {`]
-    ).concat("}");
+    const computeOutput = output.computeOutput ?? ((list) => {
+      return list.reduce(
+        (result, entry) => {
+          debug_default('adding "%O" to the index', entry);
+          result.push(`  ${entry.name}: () => import('${entry.importPath}'),`);
+          return result;
+        },
+        [`export const ${exportName} = {`]
+      ).concat("}").join("\n");
+    });
     await mkdir(outputDir, { recursive: true });
-    await writeFile(outputPath, outputContents.join("\n"));
+    await writeFile(outputPath, computeOutput(entries.flat(2)));
   }
 };
 export {

package/build/src/helpers.d.ts

@@ -0,0 +1,40 @@
+import { type SgNode } from '@ast-grep/napi';
+import type { Import } from './types/common.ts';
+/**
+ * Finds an import reference inside a code snippet
+ */
+export declare function findImport(code: string, importReference: string): Promise<Import | null>;
+/**
+ * Returns a node that represents a TypeScript class or null
+ * when unable to find the class.
+ */
+export declare function inspectClass(node: SgNode): SgNode | null;
+/**
+ * Returns an array of SgNodes for class methods. The input node
+ * must represent a class.
+ */
+export declare function inspectClassMethods(node: SgNode): SgNode[];
+/**
+ * Converts an array of SgNode to plain text by removing whitespaces,
+ * identation and comments in between. Tested with the following
+ * children nodes only.
+ *
+ * - MemberExpression
+ * - Identifer
+ */
+export declare function nodeToPlainText(node: SgNode): string;
+/**
+ * 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.
+ */
+export declare function inspectMethodArguments(node: SgNode, methodCalls: string[]): SgNode[];
+/**
+ * Inspect the validator direct usage code snippets. A member expression
+ * calling the ".validate" method is considered as direct usage of
+ * the validator.
+ */
+export declare function searchValidatorDirectUsage(node: SgNode): SgNode[];

package/build/src/paths_resolver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Encapsulates the API to resolve import specifiers with the ability
+ * to define customer resolver.
+ */
+export declare class PathsResolver {
+    #private;
+    /**
+     * Define a custom resolver that resolves a path
+     */
+    use(resolver: (specifier: string) => string): void;
+    /**
+     * Resolve import specifier
+     */
+    resolve(specifier: string): string;
+}

package/build/src/shortcuts_manager.d.ts

@@ -0,0 +1,24 @@
+import { type ShortcutsManagerOptions } from './types/common.ts';
+/**
+ * Manages keyboard shortcuts for development server
+ */
+export declare class ShortcutsManager {
+    #private;
+    constructor(options: ShortcutsManagerOptions);
+    /**
+     * Set server url for opening in browser
+     */
+    setServerUrl(url: string): void;
+    /**
+     * Initialize keyboard shortcuts
+     */
+    setup(): void;
+    /**
+     * Show available keyboard shortcuts
+     */
+    showHelp(): void;
+    /**
+     * Cleanup keyboard shortcuts
+     */
+    cleanup(): void;
+}

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

@@ -0,0 +1,115 @@
+export type ScannedController = {
+    name: string;
+    path: string;
+    method: string;
+    import: {
+        type: 'default';
+        specifier: string;
+        value: string;
+    };
+};
+export type ScannedValidator = {
+    name: string;
+    import: {
+        type: 'namespace' | 'default' | 'named';
+        specifier: string;
+        value: string;
+    };
+};
+/**
+ * Output of scanned route
+ */
+export type ScannedRoute = {
+    /**
+     * A unique name for the route provided by AdonisJS http-server. It
+     * could be duplicate across domains.
+     */
+    name: string;
+    /**
+     * HTTP methods for which the route is defined
+     */
+    methods: string[];
+    /**
+     * HTTP method for which the route is defined
+     */
+    domain: string;
+    /**
+     * The route pattern
+     */
+    pattern: string;
+    /**
+     * Route tokens could be used for constructing a URI for
+     * the route without parsing the pattern
+     */
+    tokens: {
+        val: string;
+        old: string;
+        type: 0 | 1 | 2 | 3;
+        end: string;
+    }[];
+    /**
+     * Inferred request data accepted by the route. By default, the request
+     * data type is inferred when route is using a controller with a
+     * validator
+     */
+    request?: {
+        type: string;
+        imports: string[];
+    };
+    /**
+     * Inferred response for the route. By default, the response is only
+     * inferred when the route is using a controller.
+     */
+    response?: {
+        type: string;
+        imports: string[];
+    };
+    /**
+     * Extracted validators info, only when using the controller.
+     */
+    validators?: ScannedValidator[];
+    /**
+     * Extracted controller info, only when using the controller.
+     */
+    controller?: ScannedController;
+};
+/**
+ * The route accepted by the routes scanner when initiating
+ * the scanning process.
+ */
+export type RoutesListItem = {
+    name?: string;
+    pattern: string;
+    domain: string;
+    methods: string[];
+    controllerReference?: {
+        importExpression: string;
+        method?: string;
+    };
+    tokens: {
+        val: string;
+        old: string;
+        type: 0 | 1 | 2 | 3;
+        end: string;
+    }[];
+};
+/**
+ * Rules accepted by the route scanner.
+ */
+export type RoutesScannerRules = {
+    /**
+     * An array of route names or controller+method paths to skip from
+     * the processing
+     */
+    skip: string[];
+    /**
+     * Define custom response type for a route by its name or the
+     * controller+method path
+     */
+    response: Record<string, ScannedRoute['response']>;
+    /**
+     * Define custom request data type for a route by its name
+     * or the controller+method path
+     */
+    request: Record<string, ScannedRoute['response']>;
+};

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

@@ -1,4 +1,24 @@
+import type { Logger } from '@poppinss/cliui';
+import { type Prettify } from '@poppinss/utils/types';
 import { type BundlerHooks, type DevServerHooks, type TestRunnerHooks, type WatcherHooks } from './hooks.ts';
+/**
+ * Marks a given optional property as required
+ */
+export type AsRequired<T, K extends keyof T> = Prettify<Omit<T, K> & Required<{
+    [O in K]: T[K];
+}>>;
+/**
+ * Represents an import statement
+ */
+export type Import = {
+    specifier: string;
+    isConstant: boolean;
+    clause: {
+        type: 'namespace' | 'default' | 'named';
+        value: string;
+        alias?: string;
+    };
+};
 /**
  * File inspected by the filesystem based upon the provided globs
  * and the current file path
@@ -147,3 +167,26 @@ export type TestRunnerOptions = {
  * Options accepted by the project bundler
  */
 export type BundlerOptions = AssemblerRcFile;
+/**
+ * Keyboard shortcut definition
+ */
+export interface KeyboardShortcut {
+    key: string;
+    description: string;
+    handler: () => void;
+}
+/**
+ * Callbacks for keyboard shortcuts actions
+ */
+export interface KeyboardShortcutsCallbacks {
+    onRestart: () => void;
+    onClear: () => void;
+    onQuit: () => void;
+}
+/**
+ * Shortcuts manager options
+ */
+export interface ShortcutsManagerOptions {
+    logger: Logger;
+    callbacks: KeyboardShortcutsCallbacks;
+}

package/build/src/utils.d.ts

@@ -72,6 +72,11 @@ export declare function copyFiles(files: string[], cwd: string, outDir: string):
  * only one argument as a string value.
  */
 export declare function memoize<Result>(fn: (input: string) => any, maxKeys?: number): (input: string) => Result;
+/**
+ * Returns a boolean telling if the path value is a relative
+ * path starting with "./" or "../"
+ */
+export declare function isRelative(pathValue: string): boolean;
 /**
  * Imports a selected set of lazy hooks and creates an instance of the
  * Hooks class

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@adonisjs/assembler",
   "description": "Provides utilities to run AdonisJS development server and build project for production",
-  "version": "8.0.0-next.1",
+  "version": "8.0.0-next.3",
   "engines": {
     "node": ">=24.0.0"
   },
+  "imports": {
+    "#tests/*": "./tests/*.ts"
+  },
   "main": "build/index.js",
   "type": "module",
   "files": [
@@ -15,6 +18,7 @@
   "exports": {
     ".": "./build/index.js",
     "./code_transformer": "./build/src/code_transformer/main.js",
+    "./routes_scanner": "./build/src/code_scanners/routes_scanner/main.js",
     "./types": "./build/src/types/main.js"
   },
   "scripts": {
@@ -30,45 +34,48 @@
     "release": "release-it",
     "version": "npm run build",
     "prepublishOnly": "npm run build",
-    "quick:test": "cross-env NODE_DEBUG=adonisjs:assembler node --enable-source-maps --import=@poppinss/ts-exec bin/test.ts"
+    "quick:test": "cross-env NODE_DEBUG=adonisjs:assembler node --enable-source-maps --import=@poppinss/ts-exec --experimental-import-meta-resolve bin/test.ts"
   },
   "devDependencies": {
     "@adonisjs/eslint-config": "^3.0.0-next.0",
     "@adonisjs/prettier-config": "^1.4.5",
     "@adonisjs/tsconfig": "^2.0.0-next.0",
-    "@japa/assert": "^4.0.1",
+    "@japa/assert": "^4.1.1",
     "@japa/file-system": "^2.3.2",
-    "@japa/runner": "^4.2.0",
-    "@japa/snapshot": "^2.0.8",
-    "@poppinss/ts-exec": "^1.2.1",
+    "@japa/runner": "^4.4.0",
+    "@japa/snapshot": "^2.0.9",
+    "@poppinss/ts-exec": "^1.4.1",
     "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^22.15.29",
-    "@types/picomatch": "^4.0.0",
+    "@types/node": "^24.3.0",
+    "@types/picomatch": "^4.0.2",
     "@types/pretty-hrtime": "^1.0.3",
     "c8": "^10.1.3",
-    "cross-env": "^7.0.3",
+    "cross-env": "^10.0.0",
     "del-cli": "^6.0.0",
-    "eslint": "^9.28.0",
+    "eslint": "^9.34.0",
     "hot-hook": "^0.4.1-next.0",
     "p-event": "^6.0.1",
-    "prettier": "^3.5.3",
-    "release-it": "^19.0.3",
+    "prettier": "^3.6.2",
+    "release-it": "^19.0.4",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   },
   "dependencies": {
     "@adonisjs/env": "^6.2.0",
     "@antfu/install-pkg": "^1.1.0",
-    "@poppinss/cliui": "^6.4.3",
-    "@poppinss/hooks": "^7.2.5",
-    "@poppinss/utils": "^7.0.0-next.1",
+    "@ast-grep/napi": "^0.39.4",
+    "@poppinss/cliui": "^6.4.4",
+    "@poppinss/hooks": "^7.2.6",
+    "@poppinss/utils": "^7.0.0-next.3",
     "chokidar": "^4.0.3",
     "dedent": "^1.6.0",
     "execa": "^9.6.0",
     "fast-glob": "^3.3.3",
     "get-port": "^7.1.0",
     "junk": "^4.0.1",
-    "picomatch": "^4.0.2",
+    "open": "^10.2.0",
+    "parse-imports": "^2.2.1",
+    "picomatch": "^4.0.3",
     "pretty-hrtime": "^1.0.3",
     "tmp-cache": "^1.1.0",
     "ts-morph": "^26.0.0"