@adonisjs/assembler 8.0.0-next.14 → 8.0.0-next.16

package/build/index.js

@@ -1,7 +1,11 @@
 import {
   FileBuffer,
   IndexGenerator
-} from "./chunk-TWCIFDZF.js";
+} from "./chunk-YFDLKKOA.js";
+import {
+  RoutesScanner
+} from "./chunk-WG7JQZUU.js";
+import "./chunk-TIKQQRMX.js";
 import {
   VirtualFileSystem,
   copyFiles,
@@ -10,11 +14,12 @@ import {
   loadHooks,
   memoize,
   parseConfig,
+  readTsConfig,
   run,
   runNode,
   throttle,
   watch
-} from "./chunk-7ANGUQDV.js";
+} from "./chunk-HRE5L24F.js";
 
 // src/bundler.ts
 import dedent from "dedent";
@@ -223,6 +228,7 @@ import prettyHrtime from "pretty-hrtime";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import string3 from "@poppinss/utils/string";
 import { join as join2, relative as relative3 } from "path/posix";
+import { readFile, unlink } from "fs/promises";
 import { RuntimeException } from "@poppinss/utils/exception";
 
 // src/file_system.ts
@@ -388,16 +394,16 @@ var FileSystem = class {
   constructor(cwd, tsConfig, rcFile) {
     this.#cwd = cwd;
     this.#tsConfig = tsConfig;
-    const files = tsConfig.fileNames;
+    const files = tsConfig.config.files ?? [];
     const metaFiles = rcFile.metaFiles ?? [];
     const testSuites = rcFile.suites ?? [];
-    const outDir = tsConfig.raw.compilerOptions?.outDir;
+    const outDir = tsConfig.config.compilerOptions?.outDir;
     for (const file of files) {
       this.#scannedTypeScriptFiles.add(string2.toUnixSlash(file));
     }
-    this.#includes = tsConfig.raw.include || DEFAULT_INCLUDES;
+    this.#includes = tsConfig.config.include || DEFAULT_INCLUDES;
     this.#excludes = ALWAYS_EXCLUDE.concat(
-      tsConfig.raw.exclude || (outDir ? DEFAULT_EXCLUDES.concat(outDir) : DEFAULT_EXCLUDES)
+      tsConfig.config.exclude || (outDir ? DEFAULT_EXCLUDES.concat(outDir) : DEFAULT_EXCLUDES)
     );
     const metaFilesWithReloads = [];
     const metaFilesWithoutReloads = [];
@@ -439,10 +445,10 @@ var FileSystem = class {
     if ((relativePath.endsWith(".ts") || relativePath.endsWith(".tsx")) && !relativePath.endsWith(".d.ts")) {
       return true;
     }
-    if (this.#tsConfig.options.allowJs && relativePath.endsWith(".js")) {
+    if (this.#tsConfig.config.compilerOptions?.allowJs && relativePath.endsWith(".js")) {
       return true;
     }
-    if (this.#tsConfig.options.resolveJsonModule && relativePath.endsWith(".json")) {
+    if (this.#tsConfig.config.compilerOptions?.resolveJsonModule && relativePath.endsWith(".json")) {
       return true;
     }
     return false;
@@ -697,6 +703,11 @@ var DevServer = class _DevServer {
    * Index generator for managing auto-generated index files
    */
   #indexGenerator;
+  /**
+   * Routes scanner to scan routes and infer route request and
+   * response data
+   */
+  #routesScanner;
   /**
    * Hooks to execute custom actions during the dev server lifecycle
    */
@@ -743,7 +754,12 @@ var DevServer = class _DevServer {
     this.#shortcutsManager?.cleanup();
   }
   /**
-   * 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() {
     return this.#mode;
@@ -787,6 +803,18 @@ var DevServer = class _DevServer {
   #isAdonisJSReadyMessage(message) {
     return message !== null && typeof message === "object" && "isAdonisJS" in message && "environment" in message && message.environment === "web";
   }
+  /**
+   * Type guard to check if child process message contains routes information
+   *
+   * Validates that a message from the child process contains the expected
+   * structure with routes file location from the AdonisJS server.
+   *
+   * @param message - Unknown message from child process
+   * @returns True if message contains routes file location
+   */
+  #isAdonisJSRoutesMessage(message) {
+    return message !== null && typeof message === "object" && "routesFileLocation" in message;
+  }
   /**
    * Displays server information and executes hooks after server startup
    *
@@ -888,6 +916,66 @@ var DevServer = class _DevServer {
     }
     return this.#indexGenerator.removeFile(filePath);
   }
+  /**
+   * Re-scans routes when a file is modified during hot reloading
+   *
+   * Invalidates the routes cache for the given file and triggers route
+   * scanning hooks if the invalidation was successful.
+   *
+   * @param filePath - Absolute path to the file that was modified
+   *
+   * @example
+   * await devServer.#reScanRoutes('/path/to/routes.ts')
+   */
+  async #reScanRoutes(filePath) {
+    if (!this.#routesScanner) {
+      return;
+    }
+    const invalidated = await this.#routesScanner.invalidate(filePath);
+    if (invalidated) {
+      await this.#hooks.runner("routesScanned").run(this, this.#routesScanner);
+    }
+  }
+  /**
+   * Processes routes received from the AdonisJS server
+   *
+   * Executes routesCommitted hooks and optionally scans routes if scanning
+   * hooks are registered. Creates a routes scanner instance if needed and
+   * processes routes for each domain.
+   *
+   * @param routesList - Routes organized by domain
+   *
+   * @example
+   * await devServer.#processRoutes({
+   *   'example.com': [
+   *     { pattern: '/', handler: 'HomeController.index' }
+   *   ]
+   * })
+   */
+  #processRoutes = throttle(async (routesFileLocation) => {
+    const scanRoutes = this.#hooks.has("routesScanning") || this.#hooks.has("routesScanned");
+    const shareRoutes = this.#hooks.has("routesCommitted");
+    if (!scanRoutes && !shareRoutes) {
+      unlink(routesFileLocation).catch(() => {
+      });
+      return;
+    }
+    const routesJSON = await readFile(routesFileLocation, "utf-8");
+    const routesList = JSON.parse(routesJSON);
+    unlink(routesFileLocation).catch(() => {
+    });
+    if (shareRoutes) {
+      await this.#hooks.runner("routesCommitted").run(this, routesList);
+    }
+    if (scanRoutes) {
+      this.#routesScanner = new RoutesScanner(this.cwdPath, []);
+      await this.#hooks.runner("routesScanning").run(this, this.#routesScanner);
+      for (const domain of Object.keys(routesList)) {
+        await this.#routesScanner.scan(routesList[domain]);
+      }
+      await this.#hooks.runner("routesScanned").run(this, this.#routesScanner);
+    }
+  }, "processRoutes");
   /**
    * Registers hooks for file system events and server restart triggers
    *
@@ -899,20 +987,36 @@ var DevServer = class _DevServer {
       this.#regenerateIndex(absolutePath, "add");
       this.#handleFileChange(relativePath, absolutePath, "add");
     });
-    this.#hooks.add(
-      "fileChanged",
-      (relativePath, absolutePath, info) => this.#handleFileChange(relativePath, absolutePath, "update", info)
-    );
+    this.#hooks.add("fileChanged", (relativePath, absolutePath, info) => {
+      if (info.hotReloaded) {
+        this.#reScanRoutes(absolutePath);
+      }
+      this.#handleFileChange(relativePath, absolutePath, "update", info);
+    });
     this.#hooks.add("fileRemoved", (relativePath, absolutePath) => {
       this.#regenerateIndex(absolutePath, "delete");
       this.#handleFileChange(relativePath, absolutePath, "delete");
     });
   }
   /**
-   * Initiate the state for DevServer and executes the init hooks
+   * Initializes the development server state and executes init hooks
+   *
+   * Parses TypeScript configuration, sets up file system, loads hooks,
+   * initializes the index generator, and prepares the server for the
+   * specified mode (HMR, watch, or static).
+   *
+   * @param ts - TypeScript module reference
+   * @param mode - Server mode (hmr, watch, or static)
+   * @returns True if initialization succeeds, false if tsconfig parsing fails
+   *
+   * @example
+   * const success = await devServer.#init(ts, 'hmr')
+   * if (!success) {
+   *   console.error('Failed to initialize dev server')
+   * }
    */
-  async #init(ts, mode) {
-    const tsConfig = parseConfig(this.cwd, ts);
+  async #init(mode) {
+    const tsConfig = readTsConfig(this.cwdPath);
     if (!tsConfig) {
       this.#onError?.(new RuntimeException("Unable to parse tsconfig file"));
       return false;
@@ -948,9 +1052,13 @@ var DevServer = class _DevServer {
    *
    * Creates a new Node.js child process to run the server script with the
    * specified port and configuration. Sets up message handlers for server
-   * ready notifications and hot-hook events.
+   * ready notifications, routes sharing, and hot-hook events. Executes
+   * devServerStarting hooks before spawning the process.
    *
    * @param port - Port number for the server to listen on
+   *
+   * @example
+   * await devServer.#startHTTPServer('3333')
    */
   async #startHTTPServer(port) {
     await this.#hooks.runner("devServerStarting").run(this);
@@ -968,6 +1076,9 @@ var DevServer = class _DevServer {
           debug_default("received http server ready message %O", message);
           await this.#postServerReady(message);
           resolve();
+        } else if (this.#isAdonisJSRoutesMessage(message)) {
+          debug_default("received routes location from the server %O", message);
+          await this.#processRoutes(message.routesFileLocation);
         } else if (this.#mode === "hmr" && this.#isHotHookMessage(message)) {
           debug_default("received hot-hook message %O", message);
           const absolutePath = message.path ? string3.toUnixSlash(message.path) : "";
@@ -1006,27 +1117,50 @@ var DevServer = class _DevServer {
     });
   }
   /**
-   * 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) {
     this.#onClose = callback;
     return 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) {
     this.#onError = callback;
     return 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()
    */
   async close() {
     this.#cleanupKeyboardShortcuts();
@@ -1037,12 +1171,20 @@ var DevServer = class _DevServer {
     }
   }
   /**
-   * 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)
    */
-  async start(ts) {
-    const initiated = await this.#init(ts, this.options.hmr ? "hmr" : "static");
+  async start() {
+    const initiated = await this.#init(this.options.hmr ? "hmr" : "static");
     if (!initiated) {
       return;
     }
@@ -1059,13 +1201,22 @@ var DevServer = class _DevServer {
     await this.#startHTTPServer(this.#stickyPort);
   }
   /**
-   * 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 })
    */
-  async startAndWatch(ts, options) {
-    const initiated = await this.#init(ts, "watch");
+  async startAndWatch(options) {
+    const initiated = await this.#init("watch");
     if (!initiated) {
       return;
     }
@@ -1429,8 +1580,8 @@ var TestRunner = class {
    * @param ts - TypeScript module reference for parsing configuration
    * @param options - Watch options including polling mode for file system monitoring
    */
-  async runAndWatch(ts, options) {
-    const tsConfig = parseConfig(this.cwd, ts);
+  async runAndWatch(options) {
+    const tsConfig = readTsConfig(this.cwdPath);
     if (!tsConfig) {
       this.#onError?.(new RuntimeException2("Unable to parse tsconfig file"));
       return;

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

@@ -105,7 +105,7 @@ export declare class RoutesScanner {
      *
      * @param controllerPath - Path to the controller file to invalidate
      */
-    invalidate(controllerPath: string): Promise<void>;
+    invalidate(controllerPath: string): Promise<boolean>;
     /**
      * Scans an array of Route list items and fetches their validators,
      * controllers, and request/response types.