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

package/build/{chunk-7ANGUQDV.js → chunk-HRE5L24F.js}

@@ -26,6 +26,7 @@ import { importDefault } from "@poppinss/utils";
 import { copyFile, mkdir } from "fs/promises";
 import { EnvLoader, EnvParser } from "@adonisjs/env";
 import chokidar from "chokidar";
+import { parseTsconfig } from "get-tsconfig";
 import { basename, dirname, isAbsolute, join, relative } from "path";
 var DEFAULT_NODE_ARGS = ["--import=@poppinss/ts-exec", "--enable-source-maps"];
 function parseConfig(cwd, ts) {
@@ -65,6 +66,29 @@ function parseConfig(cwd, ts) {
   }
   return parsedConfig;
 }
+function readTsConfig(cwd) {
+  const tsConfigPath = join(cwd, "tsconfig.json");
+  debug_default('reading config file from location "%s"', tsConfigPath);
+  try {
+    const tsConfig = parseTsconfig(tsConfigPath);
+    if (tsConfig.include) {
+      tsConfig.include = tsConfig.include.map((resolvedPath) => {
+        return resolvedPath.replace(`${cwd}/`, "");
+      });
+    }
+    if (tsConfig.exclude) {
+      tsConfig.exclude = tsConfig.exclude.map((resolvedPath) => {
+        return resolvedPath.replace(`${cwd}/`, "");
+      });
+    }
+    return {
+      path: tsConfigPath,
+      config: tsConfig
+    };
+  } catch {
+    return null;
+  }
+}
 function runNode(cwd, options) {
   const childProcess = execaNode(options.script, options.scriptArgs, {
     nodeOptions: DEFAULT_NODE_ARGS.concat(options.nodeArgs),
@@ -184,8 +208,9 @@ function throttle(fn, name) {
       return;
     }
     isBusy = true;
-    debug_default('executing "%s" function', name);
+    debug_default('executing throttled function "%s"', name);
     await fn(...args);
+    debug_default('executed throttled function "%s"', name);
     isBusy = false;
     if (hasQueuedCalls) {
       hasQueuedCalls = false;
@@ -243,6 +268,30 @@ var VirtualFileSystem = class {
     };
     this.#matcher = picomatch(this.#options.glob ?? DEFAULT_GLOB, this.#picoMatchOptions);
   }
+  /**
+   * Currently the PathsResolver relies on a non-standard way of resolving
+   * absolute paths or paths with subpath imports. Because of which, the
+   * on-disk file could be TypeScript, while the resolved filepath is
+   * JavaScript.
+   *
+   * To overcome this limitation, we start by first looking for a `.ts` file
+   * (because of high probability) and then look for `.js` file
+   */
+  async #readTSOrJSFile(filePath) {
+    if (filePath.endsWith(".js")) {
+      try {
+        const contents = await readFile(filePath.replace(/\.js$/, ".ts"), "utf-8");
+        debug_default('read as TypeScript file "%s"', filePath);
+        return contents;
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return readFile(filePath, "utf-8");
+        }
+        throw error;
+      }
+    }
+    return readFile(filePath, "utf-8");
+  }
   /**
    * Scans the filesystem to collect the files. Newly files must
    * be added via the ".add" method.
@@ -357,7 +406,7 @@ var VirtualFileSystem = class {
       debug_default('returning AST nodes from cache "%s"', filePath);
       return cached;
     }
-    const fileContents = await readFile(filePath, "utf-8");
+    const fileContents = await this.#readTSOrJSFile(filePath);
     debug_default('parsing "%s" file to AST', filePath);
     this.#astCache.set(filePath, parse(Lang.TypeScript, fileContents).root());
     return this.#astCache.get(filePath);
@@ -371,8 +420,13 @@ var VirtualFileSystem = class {
    * @param filePath - Optional file path to clear. If omitted, clears entire cache
    */
   invalidate(filePath) {
-    debug_default('invalidate AST cache "%s"', filePath);
-    filePath ? this.#astCache.delete(filePath) : this.#astCache.clear();
+    if (filePath) {
+      debug_default('invalidate AST cache "%s"', filePath);
+      this.#astCache.delete(filePath);
+    } else {
+      debug_default("clear AST cache");
+      this.#astCache.clear();
+    }
   }
   /**
    * Clear all scanned files from memory
@@ -388,6 +442,7 @@ var VirtualFileSystem = class {
 export {
   debug_default,
   parseConfig,
+  readTsConfig,
   runNode,
   run,
   watch,

package/build/chunk-WG7JQZUU.js

@@ -0,0 +1,475 @@
+import {
+  findImport,
+  inspectClass,
+  inspectClassMethods,
+  inspectMethodArguments,
+  nodeToPlainText,
+  searchValidatorDirectUsage
+} from "./chunk-TIKQQRMX.js";
+import {
+  VirtualFileSystem,
+  debug_default,
+  isRelative
+} from "./chunk-HRE5L24F.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 { join } from "path";
+import { resolve } from "import-meta-resolve";
+import { fileURLToPath, pathToFileURL } from "url";
+var PathsResolver = class {
+  /**
+   * The root of the application from where we will resolve
+   * paths.
+   */
+  #appRoot;
+  /**
+   * Cache of resolved paths to avoid resolving the same specifier multiple times
+   */
+  #resolvedPaths = {};
+  /**
+   * The resolver function used to resolve import specifiers
+   */
+  #resolver = (specifier, parentPath) => resolve(specifier, parentPath);
+  constructor(appRoot) {
+    this.#appRoot = pathToFileURL(join(appRoot, "index.js")).href;
+  }
+  /**
+   * 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, this.#appRoot));
+    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 as pathToFileURL2 } 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 = pathToFileURL2(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;
+  /**
+   * 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;
+    this.pathsResolver = new PathsResolver(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: []
+    };
+    debug_default('computed route "%s" response %O', route.name, route.response);
+  }
+  /**
+   * 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);
+    debug_default('computed route "%s" validators %O', route.name, route.validators);
+    route.request = await this.#computeRequestTypes?.(route, controller, this) ?? this.#prepareRequestTypes(route);
+    debug_default('computed route "%s" request input %O', route.name, route.request);
+  }
+  /**
+   * Scans a route that is not using a controller
+   */
+  #processRouteWithoutController(route) {
+    if (!route.name) {
+      debug_default(`skipping route "%s" as it does not have a name`, 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]
+    };
+    debug_default("scanned route without controller %O", scannedRoute);
+    this.#scannedRoutes.push(scannedRoute);
+  }
+  /**
+   * Scans a route that is using a controller reference
+   */
+  async #processRouteWithController(route, vfs) {
+    if (!route.handler.importExpression) {
+      return this.#processRouteWithoutController(route);
+    }
+    const controller = await this.#inspectControllerSpecifier(
+      route.handler.importExpression,
+      route.handler.method
+    );
+    if (!controller) {
+      return this.#processRouteWithoutController(route);
+    }
+    debug_default('processing route "%s" with inspected controller %O', route.name, controller);
+    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
+    };
+    debug_default("scanned route %O", scannedRoute);
+    this.#scannedRoutes.push(scannedRoute);
+    if (!scannedRoute.request || !scannedRoute.response) {
+      debug_default("tracking controller for rescanning %O", scannedRoute);
+      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)) {
+      debug_default("route skipped route: %O, rules: %O", route, this.rules);
+      return;
+    }
+    if (typeof route.handler === "function") {
+      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 || !controllerRoutes.length) {
+      debug_default(
+        '"%s" controllers is not part of scanned controllers %O',
+        controllerPath,
+        this.#controllerRoutes
+      );
+      return false;
+    }
+    for (let scannedRoute of controllerRoutes) {
+      if (scannedRoute.controller) {
+        debug_default("invalidating route %O", scannedRoute);
+        const vfs = new VirtualFileSystem(this.#appRoot);
+        await this.#setResponse(scannedRoute, scannedRoute.controller);
+        await this.#setRequest(scannedRoute, scannedRoute.controller, vfs);
+      }
+    }
+    return true;
+  }
+  /**
+   * 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 (const route of routes) {
+      await this.#processRoute(route, vfs);
+    }
+    vfs.invalidate();
+  }
+};
+
+export {
+  RoutesScanner
+};

package/build/{chunk-TWCIFDZF.js → chunk-YFDLKKOA.js}

@@ -3,7 +3,7 @@ import {
   debug_default,
   removeExtension,
   throttle
-} from "./chunk-7ANGUQDV.js";
+} from "./chunk-HRE5L24F.js";
 
 // src/index_generator/source.ts
 import string from "@poppinss/utils/string";