@adonisjs/assembler 8.0.0-next.2 → 8.0.0-next.20

package/build/chunk-NAASGAFO.js

@@ -0,0 +1,478 @@
+import {
+  findImport,
+  inspectClass,
+  inspectClassMethods,
+  inspectMethodArguments,
+  nodeToPlainText,
+  searchValidatorDirectUsage
+} from "./chunk-TIKQQRMX.js";
+import {
+  VirtualFileSystem,
+  debug_default,
+  isRelative
+} from "./chunk-JFBQ4OEM.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, rewriteAliasImportExtension = false) {
+    if (isRelative(specifier)) {
+      throw new Error("Cannot resolve relative paths using PathsResolver");
+    }
+    const cacheKey = specifier;
+    const cached = this.#resolvedPaths[cacheKey];
+    if (cached) {
+      return cached;
+    }
+    let resolvedPath = fileURLToPath(this.#resolver(specifier, this.#appRoot));
+    if (rewriteAliasImportExtension && specifier.startsWith("#") && resolvedPath.endsWith(".js")) {
+      resolvedPath = resolvedPath.replace(/\.js$/, ".ts");
+    }
+    this.#resolvedPaths[cacheKey] = resolvedPath;
+    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((methodNode) => {
+    const methodName = methodNode.find({ rule: { kind: "property_identifier" } });
+    return methodName?.text() === controller.method;
+  });
+  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, true)),
+      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.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);
+  }
+  /**
+   * Scans a route that is using a controller reference
+   */
+  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);
+    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-TIKQQRMX.js

@@ -0,0 +1,116 @@
+// src/helpers.ts
+import { parseImports } from "parse-imports";
+async function findImport(code, importReference) {
+  const importIdentifier = importReference.split(".")[0];
+  for (const $import of await parseImports(code, {})) {
+    if (!$import.importClause) {
+      continue;
+    }
+    if (!$import.moduleSpecifier.value) {
+      continue;
+    }
+    if ($import.importClause.default === importIdentifier) {
+      return {
+        specifier: $import.moduleSpecifier.value,
+        isConstant: $import.moduleSpecifier.isConstant,
+        clause: {
+          type: "default",
+          value: importIdentifier
+        }
+      };
+    }
+    if ($import.importClause.namespace === importIdentifier) {
+      return {
+        specifier: $import.moduleSpecifier.value,
+        isConstant: $import.moduleSpecifier.isConstant,
+        clause: {
+          type: "namespace",
+          value: importIdentifier
+        }
+      };
+    }
+    const namedImport = $import.importClause.named.find(({ binding }) => {
+      return binding === importIdentifier;
+    });
+    if (namedImport) {
+      return {
+        specifier: $import.moduleSpecifier.value,
+        isConstant: $import.moduleSpecifier.isConstant,
+        clause: {
+          type: "named",
+          value: namedImport.specifier,
+          ...namedImport.binding !== namedImport.specifier ? {
+            alias: namedImport.binding
+          } : {}
+        }
+      };
+    }
+  }
+  return null;
+}
+function inspectClass(node) {
+  return node.find({
+    rule: {
+      kind: "class_declaration"
+    }
+  });
+}
+function inspectClassMethods(node) {
+  return node.findAll({
+    rule: {
+      kind: "method_definition"
+    }
+  });
+}
+function nodeToPlainText(node) {
+  let out = [];
+  function toText(one) {
+    const children = one.children();
+    if (!children.length) {
+      out.push(one.text());
+    } else {
+      children.forEach((child) => toText(child));
+    }
+  }
+  toText(node);
+  return out.join("");
+}
+function inspectMethodArguments(node, methodCalls) {
+  const matchingExpressions = node.findAll({
+    rule: {
+      any: methodCalls.map((methodCall) => {
+        return {
+          pattern: {
+            context: `${methodCall}($$$ARGUMENTS)`,
+            selector: "call_expression"
+          }
+        };
+      })
+    }
+  });
+  return matchingExpressions.flatMap((matchingExpression) => {
+    return matchingExpression.findAll({ rule: { kind: "arguments" } });
+  });
+}
+function searchValidatorDirectUsage(node) {
+  const matchingExpressions = node.findAll({
+    rule: {
+      pattern: {
+        context: "$$$VALIDATOR.validate($$$)",
+        selector: "call_expression"
+      }
+    }
+  });
+  return matchingExpressions.flatMap((expression) => {
+    return expression.getMultipleMatches("VALIDATOR");
+  });
+}
+
+export {
+  findImport,
+  inspectClass,
+  inspectClassMethods,
+  nodeToPlainText,
+  inspectMethodArguments,
+  searchValidatorDirectUsage
+};

package/build/index.d.ts

@@ -1,3 +1,6 @@
 export { Bundler } from './src/bundler.ts';
 export { DevServer } from './src/dev_server.ts';
 export { TestRunner } from './src/test_runner.ts';
+export { FileBuffer } from './src/file_buffer.ts';
+export { VirtualFileSystem } from './src/virtual_file_system.ts';
+export { SUPPORTED_PACKAGE_MANAGERS } from './src/bundler.ts';