@adonisjs/assembler 8.0.0-next.2 → 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']
-  }
 })
 ```
 

package/build/index.js

@@ -609,7 +609,9 @@ var ShortcutsManager = class {
    * Initialize keyboard shortcuts
    */
   setup() {
-    if (!process.stdin.isTTY) return;
+    if (!process.stdin.isTTY) {
+      return;
+    }
     process.stdin.setRawMode(true);
     this.#keyPressHandler = (data) => this.#handleKeyPress(data.toString());
     process.stdin.on("data", this.#keyPressHandler);
@@ -618,9 +620,13 @@ var ShortcutsManager = class {
    * Handle key press events
    */
   #handleKeyPress(key) {
-    if (key === "" || key === "") return this.#callbacks.onQuit();
+    if (key === "" || key === "") {
+      return this.#callbacks.onQuit();
+    }
     const shortcut = this.#shortcuts.find((s) => s.key === key);
-    if (shortcut) shortcut.handler();
+    if (shortcut) {
+      shortcut.handler();
+    }
   }
   /**
    * Handle opening browser
@@ -643,7 +649,9 @@ var ShortcutsManager = class {
    * Cleanup keyboard shortcuts
    */
   cleanup() {
-    if (!process.stdin.isTTY) return;
+    if (!process.stdin.isTTY) {
+      return;
+    }
     process.stdin.setRawMode(false);
     process.stdin.removeListener("data", this.#keyPressHandler);
     this.#keyPressHandler = void 0;

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/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

@@ -1,27 +1,4 @@
-import type { Logger } from '@poppinss/cliui';
-/**
- * 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;
-}
+import { type ShortcutsManagerOptions } from './types/common.ts';
 /**
  * Manages keyboard shortcuts for development server
  */

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.2",
+  "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,35 +34,36 @@
     "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.4.0",
+    "@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": "^24.0.10",
-    "@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.30.1",
+    "eslint": "^9.34.0",
     "hot-hook": "^0.4.1-next.0",
     "p-event": "^6.0.1",
     "prettier": "^3.6.2",
-    "release-it": "^19.0.3",
+    "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",
+    "@ast-grep/napi": "^0.39.4",
     "@poppinss/cliui": "^6.4.4",
     "@poppinss/hooks": "^7.2.6",
     "@poppinss/utils": "^7.0.0-next.3",
@@ -68,8 +73,9 @@
     "fast-glob": "^3.3.3",
     "get-port": "^7.1.0",
     "junk": "^4.0.1",
-    "open": "^10.1.2",
-    "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"