@adonisjs/assembler 8.0.0-next.9 → 8.0.0

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

@@ -1,445 +1,172 @@
-import {
-  findImport,
-  inspectClass,
-  inspectClassMethods,
-  inspectMethodArguments,
-  nodeToPlainText,
-  searchValidatorDirectUsage
-} from "../../../chunk-TIKQQRMX.js";
-import {
-  VirtualFileSystem,
-  debug_default,
-  isRelative
-} from "../../../chunk-PORDZS62.js";
-
-// src/code_scanners/routes_scanner/main.ts
+import { m as debug_default, t as VirtualFileSystem } from "../../../virtual_file_system-bGeoWsK-.js";
+import { n as PathsResolver, t as extractValidators } from "../../../validator_extractor-Ccio_Ndi.js";
 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
+import StringBuilder from "@poppinss/utils/string_builder";
+import { parseImports } from "parse-imports";
 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();
-  }
-};
-export {
-  RoutesScanner
+	#filter;
+	#appRoot;
+	#controllerRoutes = {};
+	#scannedRoutes = [];
+	#computeResponseTypes;
+	#computeRequestTypes;
+	#extractValidators;
+	ui = cliui();
+	pathsResolver;
+	rules = {
+		request: {},
+		response: {}
+	};
+	constructor(appRoot, rulesCollection) {
+		this.#appRoot = appRoot;
+		this.pathsResolver = new PathsResolver(appRoot);
+		rulesCollection.forEach((rules) => {
+			Object.assign(this.rules.request, rules.request);
+			Object.assign(this.rules.response, rules.response);
+		});
+	}
+	#shouldSkipRoute(route) {
+		if (this.#filter) return !this.#filter(route);
+		return false;
+	}
+	#prepareRequestTypes(route) {
+		if (!route.validators) return;
+		return {
+			type: 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(`InferInput<(typeof import('${validator.import.specifier}')${validatorExport})${namespace}>`);
+				return result;
+			}, []).join("|"),
+			imports: [`import { InferInput } from '@vinejs/vine/types'`]
+		};
+	}
+	async #inspectControllerSpecifier(importExpression, method) {
+		const importedModule = [...await parseImports(importExpression)].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: string.toUnixSlash(this.pathsResolver.resolve(specifier, true)),
+			import: {
+				specifier,
+				type: "default",
+				value: name
+			}
+		};
+	}
+	async #setResponse(route, controller) {
+		route.response = await this.#computeResponseTypes?.(route, controller, this) ?? {
+			type: `ReturnType<import('${controller.import.specifier}').default['${controller.method}']>`,
+			imports: []
+		};
+		debug_default("computed route \"%s\" response %O", route.name, route.response);
+	}
+	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);
+	}
+	#processRouteWithoutController(route) {
+		if (!route.name) {
+			debug_default(`skipping route "%s" as it does not have a name`, route.pattern);
+			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);
+	}
+	async #processRouteWithController(route, vfs) {
+		if (!route.handler || !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);
+		route.name = route.name ?? new StringBuilder(controller.name).removeSuffix("Controller").snakeCase().suffix(`.${string.snakeCase(controller.method)}`).toString();
+		if (this.#shouldSkipRoute(route)) 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],
+			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);
+		}
+	}
+	async #processRoute(route, vfs) {
+		if (route.name && this.#shouldSkipRoute(route)) {
+			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);
+	}
+	defineResponse(callback) {
+		this.#computeResponseTypes = callback;
+		return this;
+	}
+	defineRequest(callback) {
+		this.#computeRequestTypes = callback;
+		return this;
+	}
+	extractValidators(callback) {
+		this.#extractValidators = callback;
+		return this;
+	}
+	getScannedRoutes() {
+		return this.#scannedRoutes;
+	}
+	getControllers() {
+		return Object.keys(this.#controllerRoutes);
+	}
+	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;
+	}
+	filter(filterFn) {
+		this.#filter = filterFn;
+		return this;
+	}
+	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/src/code_transformer/main.d.ts

@@ -1,7 +1,7 @@
 import { installPackage, detectPackageManager } from '@antfu/install-pkg';
 import { Project } from 'ts-morph';
 import { RcFileTransformer } from './rc_file_transformer.ts';
-import type { MiddlewareNode, EnvValidationNode, BouncerPolicyNode } from '../types/code_transformer.ts';
+import type { MiddlewareNode, EnvValidationNode, BouncerPolicyNode, ValidatorNode, LimiterNode, MixinDefinition, ControllerMethodNode } from '../types/code_transformer.ts';
 /**
  * This class is responsible for transforming AdonisJS project code,
  * including updating middleware, environment validations, and other
@@ -39,6 +39,15 @@ export declare class CodeTransformer {
      * @param cwd - The current working directory URL
      */
     constructor(cwd: URL);
+    /**
+     * Get directories configured in adonisrc.ts, with defaults fallback.
+     *
+     * This method reads the adonisrc.ts file and extracts the directories
+     * configuration. If a directory is not configured, the default value is used.
+     *
+     * @returns Object containing directory paths
+     */
+    getDirectories(): Record<string, string>;
     /**
      * Add new env variable validation in the `env.ts` file
      *
@@ -91,4 +100,8 @@ export declare class CodeTransformer {
      * @param policies - Array of bouncer policy entries to add
      */
     addPolicies(policies: BouncerPolicyNode[]): Promise<void>;
+    addValidator(definition: ValidatorNode): Promise<void>;
+    addLimiter(definition: LimiterNode): Promise<void>;
+    addModelMixins(modelFileName: string, mixins: MixinDefinition[]): Promise<void>;
+    addControllerMethod(definition: ControllerMethodNode): Promise<void>;
 }