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

package/build/src/code_scanners/routes_scanner/main.js

@@ -1,445 +1,8 @@
 import {
-  findImport,
-  inspectClass,
-  inspectClassMethods,
-  inspectMethodArguments,
-  nodeToPlainText,
-  searchValidatorDirectUsage
-} from "../../../chunk-TIKQQRMX.js";
-import {
-  VirtualFileSystem,
-  debug_default,
-  isRelative
-} from "../../../chunk-7ANGUQDV.js";
-
-// src/code_scanners/routes_scanner/main.ts
-import { cliui } from "@poppinss/cliui";
-import string2 from "@poppinss/utils/string";
-import { parseImports } from "parse-imports";
-import StringBuilder from "@poppinss/utils/string_builder";
-
-// src/paths_resolver.ts
-import { fileURLToPath } from "url";
-var PathsResolver = class {
-  /**
-   * Cache of resolved paths to avoid resolving the same specifier multiple times
-   */
-  #resolvedPaths = {};
-  /**
-   * The resolver function used to resolve import specifiers
-   */
-  #resolver = (specifier) => import.meta.resolve(specifier);
-  /**
-   * Define a custom resolver that resolves a path
-   *
-   * The custom resolver function will be used instead of the default
-   * import.meta.resolve() for resolving import specifiers.
-   *
-   * @param resolver - Function that takes a specifier and returns resolved path
-   */
-  use(resolver) {
-    this.#resolver = resolver;
-  }
-  /**
-   * Resolve import specifier to an absolute file path
-   *
-   * This method caches resolved paths to improve performance on repeated
-   * resolutions. Relative paths are not supported and will throw an error.
-   *
-   * @param specifier - The import specifier to resolve (must not be relative)
-   * @returns The resolved absolute file path
-   * @throws Error when attempting to resolve relative paths
-   *
-   * @example
-   * const path = resolver.resolve('#app/models/user')
-   * const path2 = resolver.resolve('@/utils/helper')
-   */
-  resolve(specifier) {
-    if (isRelative(specifier)) {
-      throw new Error("Cannot resolve relative paths using PathsResolver");
-    }
-    const cacheKey = specifier;
-    const cached = this.#resolvedPaths[cacheKey];
-    if (cached) {
-      return cached;
-    }
-    this.#resolvedPaths[cacheKey] = fileURLToPath(this.#resolver(specifier));
-    return this.#resolvedPaths[cacheKey];
-  }
-};
-
-// src/code_scanners/routes_scanner/validator_extractor.ts
-import { relative } from "path";
-import string from "@poppinss/utils/string";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
-async function extractValidators(appRoot, vfs, controller) {
-  const root = await vfs.get(controller.path);
-  const fileContents = root.text();
-  const controllerClass = inspectClass(root);
-  if (!controllerClass) {
-    debug_default(`No class defined within the "%s"`, controller.import.specifier);
-    return;
-  }
-  const method = inspectClassMethods(controllerClass).find((e) => {
-    return e.find({
-      rule: { kind: "property_identifier", regex: `\\b${controller.method}\\b` }
-    });
-  });
-  if (!method) {
-    debug_default(`Unable to find "%s" method in "%s"`, controller.method, controller.import.specifier);
-    return;
-  }
-  const validationCalls = inspectMethodArguments(method, ["request.validateUsing", "vine.validate"]).map((node) => {
-    const firstArg = node.find({
-      rule: { any: [{ kind: "identifier" }, { kind: "member_expression" }] }
-    });
-    if (!firstArg) {
-      return;
-    }
-    return nodeToPlainText(firstArg);
-  }).filter((node) => node !== void 0).concat(searchValidatorDirectUsage(method).map((node) => nodeToPlainText(node)));
-  if (!validationCalls.length) {
-    debug_default(
-      `Unable to detect any validation calls in "%s.%s" method`,
-      controller.import.specifier,
-      controller.method
-    );
-    return;
-  }
-  const controllerName = controllerClass.find({ rule: { kind: "type_identifier" } }).text();
-  const controllerURL = pathToFileURL(controller.path);
-  const imports = await Promise.all(
-    validationCalls.map(async (validationCall) => {
-      const validatorNamespace = validationCall.split(".")[0];
-      if (validatorNamespace === controllerName) {
-        return {
-          name: validationCall,
-          import: {
-            specifier: controller.import.specifier,
-            type: "default",
-            value: controllerName
-          }
-        };
-      }
-      const importCall = await findImport(fileContents, validationCall);
-      if (!importCall) {
-        debug_default(
-          'Unable to find import for "%s" used by "%s.%s" method',
-          validationCall,
-          controller.import.specifier,
-          controller.method
-        );
-        return null;
-      }
-      return {
-        name: validationCall,
-        import: {
-          specifier: isRelative(importCall.specifier) ? string.toUnixSlash(
-            relative(appRoot, fileURLToPath2(new URL(importCall.specifier, controllerURL)))
-          ) : importCall.specifier,
-          type: importCall.clause.type,
-          value: importCall.clause.value
-        }
-      };
-    })
-  );
-  return imports.filter((value) => !!value);
-}
-
-// src/code_scanners/routes_scanner/main.ts
-var RoutesScanner = class {
-  /**
-   * The root of the application from where we will resolve
-   * paths.
-   */
-  #appRoot;
-  /**
-   * Collection of routes by their controller file path. This helps
-   * us re-compute request types when the controller is changed.
-   */
-  #controllerRoutes = {};
-  /**
-   * Collection of scanned routes
-   */
-  #scannedRoutes = [];
-  /**
-   * A custom method to self compute the response type for a route. Return
-   * undefined to fallback to the default behavior
-   */
-  #computeResponseTypes;
-  /**
-   * A custom method to self compute the request type for a route. Return
-   * undefined to fallback to the default behavior
-   */
-  #computeRequestTypes;
-  /**
-   * A custom method to self extract the validators from the route controller.
-   * Return undefined to fallback to the default behavior.
-   */
-  #extractValidators;
-  /**
-   * CLI UI instance to log colorful messages and progress information
-   */
-  ui = cliui();
-  /**
-   * The paths resolver is used to convert subpath and package
-   * imports to absolute paths
-   */
-  pathsResolver = new PathsResolver();
-  /**
-   * The rules to apply when scanning routes
-   */
-  rules = {
-    skip: [],
-    request: {},
-    response: {}
-  };
-  /**
-   * Create a new RoutesScanner instance
-   *
-   * @param appRoot - The root directory of the application
-   * @param rulesCollection - Collection of rules to apply during scanning
-   */
-  constructor(appRoot, rulesCollection) {
-    this.#appRoot = appRoot;
-    rulesCollection.forEach((rules) => {
-      this.rules.skip = this.rules.skip.concat(rules.skip);
-      Object.assign(this.rules.request, rules.request);
-      Object.assign(this.rules.response, rules.response);
-    });
-    this.rules.skip = Array.from(/* @__PURE__ */ new Set([...this.rules.skip]));
-  }
-  /**
-   * Assumes the validators are from VineJS and computes the request types from them
-   *
-   * This method generates TypeScript type definitions for request validation
-   * by analyzing VineJS validators and creating Infer types.
-   *
-   * @param route - The scanned route with validators
-   * @returns Request type definition or undefined
-   */
-  #prepareRequestTypes(route) {
-    if (!route.validators) {
-      return;
-    }
-    const schemas = route.validators.reduce((result, validator) => {
-      const validatorExport = validator.import.type === "default" ? ".default" : validator.import.type === "named" ? `.${validator.import.value}` : "";
-      const [, ...segments] = validator.name.split(".");
-      const namespace = segments.map((segment) => `['${segment}']`).join("");
-      result.push(
-        `Infer<(typeof import('${validator.import.specifier}')${validatorExport})${namespace}>`
-      );
-      return result;
-    }, []);
-    return {
-      type: schemas.join("|"),
-      imports: [`import { Infer } from '@vinejs/vine/types'`]
-    };
-  }
-  /**
-   * Inspects the controller reference and fetches its import specifier
-   * and the controller name from it.
-   */
-  async #inspectControllerSpecifier(importExpression, method) {
-    const imports = [...await parseImports(importExpression)];
-    const importedModule = imports.find(
-      ($import) => $import.isDynamicImport && $import.moduleSpecifier.value
-    );
-    if (!importedModule || importedModule.moduleSpecifier.type !== "package" || !importedModule.moduleSpecifier.value) {
-      return null;
-    }
-    const specifier = importedModule.moduleSpecifier.value;
-    const name = new StringBuilder(specifier.split("/").pop()).removeSuffix("Controller").pascalCase().suffix("Controller").toString();
-    return {
-      name,
-      method: method ?? "handle",
-      path: string2.toUnixSlash(this.pathsResolver.resolve(specifier)),
-      import: {
-        specifier,
-        type: "default",
-        value: name
-      }
-    };
-  }
-  /**
-   * Defines the response type for the route
-   */
-  async #setResponse(route, controller) {
-    const responseType = await this.#computeResponseTypes?.(route, controller, this);
-    route.response = responseType ?? {
-      type: `ReturnType<import('${controller.import.specifier}').default['${controller.method}']>`,
-      imports: []
-    };
-  }
-  /**
-   * Defines the request type for the route
-   */
-  async #setRequest(route, controller, vfs) {
-    route.validators = await this.#extractValidators?.(route, controller, this) ?? await extractValidators(this.#appRoot, vfs, controller);
-    route.request = await this.#computeRequestTypes?.(route, controller, this) ?? this.#prepareRequestTypes(route);
-  }
-  /**
-   * Scans a route that is not using a controller
-   */
-  #processRouteWithoutController(route) {
-    if (!route.name) {
-      debug_default(`skipping route "%s" scanning. Missing a controller reference`, route.name);
-      return;
-    }
-    const scannedRoute = {
-      name: route.name,
-      domain: route.domain,
-      methods: route.methods,
-      pattern: route.pattern,
-      tokens: route.tokens,
-      request: this.rules.request[route.name],
-      response: this.rules.response[route.name]
-    };
-    this.#scannedRoutes.push(scannedRoute);
-  }
-  /**
-   * Scans a route that is using a controller reference
-   */
-  async #processRouteWithController(route, vfs) {
-    const controller = await this.#inspectControllerSpecifier(
-      route.controllerReference.importExpression,
-      route.controllerReference.method
-    );
-    if (!controller) {
-      return this.#processRouteWithoutController(route);
-    }
-    const routeName = route.name ?? new StringBuilder(controller.name).removeSuffix("Controller").snakeCase().suffix(`.${string2.snakeCase(controller.method)}`).toString();
-    if (this.rules.skip.includes(routeName)) {
-      return;
-    }
-    const scannedRoute = {
-      name: routeName,
-      domain: route.domain,
-      methods: route.methods,
-      pattern: route.pattern,
-      tokens: route.tokens,
-      request: this.rules.request[routeName],
-      response: this.rules.response[routeName],
-      controller
-    };
-    this.#scannedRoutes.push(scannedRoute);
-    if (!scannedRoute.request || !scannedRoute.response) {
-      this.#controllerRoutes[controller.path] ??= [];
-      this.#controllerRoutes[controller.path].push(scannedRoute);
-      if (!scannedRoute.response) {
-        await this.#setResponse(scannedRoute, controller);
-      }
-      if (!scannedRoute.request) {
-        await this.#setRequest(scannedRoute, controller, vfs);
-      }
-    }
-  }
-  /**
-   * Processing a given route list item and further scan it to
-   * fetch the controller, request and response types.
-   */
-  async #processRoute(route, vfs) {
-    if (route.name && this.rules.skip.includes(route.name)) {
-      return;
-    }
-    if (!route.controllerReference) {
-      this.#processRouteWithoutController(route);
-      return;
-    }
-    await this.#processRouteWithController(
-      route,
-      vfs
-    );
-  }
-  /**
-   * 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
-   *
-   * @param callback - Function to compute response types for routes
-   * @returns This RoutesScanner instance for method chaining
-   */
-  defineResponse(callback) {
-    this.#computeResponseTypes = callback;
-    return 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
-   *
-   * @param callback - Function to compute request types for routes
-   * @returns This RoutesScanner instance for method chaining
-   */
-  defineRequest(callback) {
-    this.#computeRequestTypes = callback;
-    return this;
-  }
-  /**
-   * Register a callback to extract validators from the route controller
-   *
-   * @param callback - Function to extract validators from controllers
-   * @returns This RoutesScanner instance for method chaining
-   */
-  extractValidators(callback) {
-    this.#extractValidators = callback;
-    return this;
-  }
-  /**
-   * Returns the scanned routes
-   *
-   * @returns Array of scanned routes with their metadata
-   */
-  getScannedRoutes() {
-    return this.#scannedRoutes;
-  }
-  /**
-   * Returns an array of controllers bound to the provided
-   * routes
-   *
-   * @returns Array of controller's absolute paths
-   */
-  getControllers() {
-    return Object.keys(this.#controllerRoutes);
-  }
-  /**
-   * Invalidating a controller will trigger computing the validators,
-   * request types and the response types.
-   *
-   * @param controllerPath - Path to the controller file to invalidate
-   */
-  async invalidate(controllerPath) {
-    const controllerRoutes = this.#controllerRoutes[controllerPath];
-    if (!controllerRoutes) {
-      return;
-    }
-    for (let scannedRoute of controllerRoutes) {
-      if (scannedRoute.controller) {
-        const vfs = new VirtualFileSystem(this.#appRoot);
-        await this.#setResponse(scannedRoute, scannedRoute.controller);
-        await this.#setRequest(scannedRoute, scannedRoute.controller, vfs);
-      }
-    }
-  }
-  /**
-   * Scans an array of Route list items and fetches their validators,
-   * controllers, and request/response types.
-   *
-   * This is the main method that processes all routes and extracts
-   * their type information for code generation purposes.
-   *
-   * @param routes - Array of route list items to scan
-   */
-  async scan(routes) {
-    const vfs = new VirtualFileSystem(this.#appRoot);
-    for (let route of routes) {
-      await this.#processRoute(route, vfs);
-    }
-    vfs.invalidate();
-  }
-};
+  RoutesScanner
+} from "../../../chunk-WG7JQZUU.js";
+import "../../../chunk-TIKQQRMX.js";
+import "../../../chunk-HRE5L24F.js";
 export {
   RoutesScanner
 };

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)
@@ -41,7 +42,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 +74,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/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/index_generator/main.js

@@ -1,7 +1,7 @@
 import {
   IndexGenerator
-} from "../../chunk-TWCIFDZF.js";
-import "../../chunk-7ANGUQDV.js";
+} from "../../chunk-YFDLKKOA.js";
+import "../../chunk-HRE5L24F.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
      *

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
@@ -111,7 +110,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

@@ -174,12 +174,9 @@ 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: Function | {
+        method: string;
+        importExpression: string | null;
     };
     /** Parsed route tokens for URI construction */
     tokens: {

package/build/src/utils.d.ts

@@ -1,6 +1,7 @@
 import Hooks from '@poppinss/hooks';
 import type tsStatic from 'typescript';
 import { type ChokidarOptions } from 'chokidar';
+import { type TsConfigResult } from 'get-tsconfig';
 import type { RunScriptOptions } from './types/common.ts';
 import { type AllHooks, type HookParams } from './types/hooks.ts';
 /**
@@ -10,11 +11,14 @@ import { type AllHooks, type HookParams } from './types/hooks.ts';
  * handling diagnostic errors and returning a parsed configuration that can be
  * used by other TypeScript operations.
  *
+ * @deprecated While we are experimenting with the readTsConfig method
+ *
  * @param cwd - The current working directory URL or string path
  * @param ts - TypeScript module reference
  * @returns Parsed TypeScript configuration or undefined if parsing failed
  */
 export declare function parseConfig(cwd: URL | string, ts: typeof tsStatic): tsStatic.ParsedCommandLine | undefined;
+export declare function readTsConfig(cwd: string): TsConfigResult | null;
 /**
  * Runs a Node.js script as a child process and inherits the stdio streams
  *
@@ -36,7 +40,7 @@ export declare function runNode(cwd: string | URL, options: RunScriptOptions): i
     buffer: false;
     stdio: "pipe" | "inherit";
     env: {
-        TZ?: string;
+        TZ?: string | undefined;
         FORCE_COLOR?: string | undefined;
     };
 }>;
@@ -58,7 +62,7 @@ export declare function run(cwd: string | URL, options: Omit<RunScriptOptions, '
     buffer: false;
     stdio: "pipe" | "inherit";
     env: {
-        TZ?: string;
+        TZ?: string | undefined;
         FORCE_COLOR?: string | undefined;
     };
 }>;