@adonisjs/assembler 7.8.2 → 8.0.0-next.0

package/build/src/bundler.d.ts

@@ -1,20 +1,41 @@
 import type tsStatic from 'typescript';
-import { type Logger } from '@poppinss/cliui';
-import type { BundlerOptions } from './types.js';
-type SupportedPackageManager = 'npm' | 'yarn' | 'yarn@berry' | 'pnpm' | 'bun';
+import type { BundlerOptions } from './types/common.ts';
+import { type SupportedPackageManager } from './types/code_transformer.ts';
 /**
  * The bundler class exposes the API to build an AdonisJS project.
  */
 export declare class Bundler {
     #private;
-    constructor(cwd: URL, ts: typeof tsStatic, options: BundlerOptions);
+    cwd: URL;
+    options: BundlerOptions;
+    ui: {
+        colors: import("@poppinss/colors/types").Colors;
+        logger: import("@poppinss/cliui").Logger;
+        table: (tableOptions?: Partial<import("@poppinss/cliui/types").TableOptions>) => import("@poppinss/cliui").Table;
+        tasks: (tasksOptions?: Partial<import("@poppinss/cliui/types").TaskManagerOptions>) => import("@poppinss/cliui").TaskManager;
+        icons: {
+            tick: string;
+            cross: string;
+            bullet: string;
+            nodejs: string;
+            pointer: string;
+            info: string;
+            warning: string;
+            squareSmallFilled: string;
+        };
+        sticker: () => import("@poppinss/cliui").Instructions;
+        instructions: () => import("@poppinss/cliui").Instructions;
+        switchMode(modeToUse: "raw" | "silent" | "normal"): void;
+        useRenderer(rendererToUse: import("@poppinss/cliui/types").RendererContract): void;
+        useColors(colorsToUse: import("@poppinss/colors/types").Colors): void;
+    };
     /**
-     * Set a custom CLI UI logger
+     * Package manager detect from the project environment
      */
-    setLogger(logger: Logger): this;
+    packageManager: SupportedPackageManager;
+    constructor(cwd: URL, ts: typeof tsStatic, options: BundlerOptions);
     /**
      * Bundles the application to be run in production
      */
     bundle(stopOnError?: boolean, client?: SupportedPackageManager): Promise<boolean>;
 }
-export {};

package/build/src/code_transformer/main.d.ts

@@ -1,7 +1,8 @@
+import { type OneOrMore } from '@poppinss/utils/types';
 import { installPackage, detectPackageManager } from '@antfu/install-pkg';
 import { Project } from 'ts-morph';
-import { RcFileTransformer } from './rc_file_transformer.js';
-import type { MiddlewareNode, EnvValidationNode, BouncerPolicyNode } from '../types.js';
+import { RcFileTransformer } from './rc_file_transformer.ts';
+import type { MiddlewareNode, EnvValidationNode, BouncerPolicyNode } from '../types/code_transformer.ts';
 /**
  * This class is responsible for updating
  */
@@ -57,4 +58,31 @@ export declare class CodeTransformer {
      * inside the `app/policies/main.ts` file.
      */
     addPolicies(policies: BouncerPolicyNode[]): Promise<void>;
+    /**
+     * Creates an index file that exports an object in which the key is the PascalCase
+     * name of the entity and the value is a dynamic import.
+     *
+     * For example, in case of controllers, the index file will be the list of controller
+     * names pointing a dynamically imported controller file.
+     *
+     * ```ts
+     * export const controllers = {
+     *   Login: () => import('#controllers/login_controller'),
+     *   Login: () => import('#controllers/login_controller'),
+     * }
+     * ```
+     *
+     * @param source
+     * @param outputPath
+     * @param importAlias
+     */
+    makeEntityIndex(input: OneOrMore<{
+        source: string;
+        importAlias?: string;
+    }>, output: {
+        destination: string;
+        exportName?: string;
+        transformName?: (name: string) => string;
+        transformImport?: (modulePath: string) => string;
+    }): Promise<void>;
 }

package/build/src/code_transformer/main.js

@@ -1,20 +1,30 @@
+import {
+  debug_default
+} from "../../chunk-RR4HCA4M.js";
+
 // src/code_transformer/main.ts
-import { join } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import string from "@poppinss/utils/string";
+import { isScriptFile } from "@poppinss/utils";
+import { fsReadAll } from "@poppinss/utils/fs";
+import { mkdir, writeFile } from "fs/promises";
+import StringBuilder from "@poppinss/utils/string_builder";
+import { basename, dirname, join, relative } from "path";
 import { installPackage, detectPackageManager } from "@antfu/install-pkg";
 import {
   Node as Node2,
-  Project as Project2,
+  Project,
   QuoteKind,
   SyntaxKind as SyntaxKind2
 } from "ts-morph";
 
 // src/code_transformer/rc_file_transformer.ts
-import { fileURLToPath } from "node:url";
+import { fileURLToPath } from "url";
 import {
   Node,
   SyntaxKind
 } from "ts-morph";
+var ALLOWED_ENVIRONMENTS = ["web", "console", "test", "repl"];
 var RcFileTransformer = class {
   #cwd;
   #project;
@@ -48,9 +58,7 @@ var RcFileTransformer = class {
     if (!environments) {
       return false;
     }
-    return !!["web", "console", "test", "repl"].find(
-      (env) => !environments.includes(env)
-    );
+    return !!ALLOWED_ENVIRONMENTS.find((env) => !environments.includes(env));
   }
   /**
    * Locate the `defineConfig` call inside the `adonisrc.ts` file
@@ -287,6 +295,7 @@ var CodeTransformer = class {
    * Directory of the adonisjs project
    */
   #cwd;
+  #cwdPath;
   /**
    * The TsMorph project
    */
@@ -305,7 +314,8 @@ var CodeTransformer = class {
   };
   constructor(cwd) {
     this.#cwd = cwd;
-    this.project = new Project2({
+    this.#cwdPath = fileURLToPath2(this.#cwd);
+    this.project = new Project({
       tsConfigFilePath: join(fileURLToPath2(this.#cwd), "tsconfig.json"),
       manipulationSettings: { quoteKind: QuoteKind.Single }
     });
@@ -404,7 +414,7 @@ var CodeTransformer = class {
    * `env.ts` file
    */
   async defineEnvValidations(definition) {
-    const kernelUrl = fileURLToPath2(new URL("./start/env.ts", this.#cwd));
+    const kernelUrl = join(this.#cwdPath, "./start/env.ts");
     const file = this.project.getSourceFileOrThrow(kernelUrl);
     const callExpressions = file.getDescendantsOfKind(SyntaxKind2.CallExpression).filter((statement) => statement.getExpression().getText() === "Env.create");
     if (!callExpressions.length) {
@@ -446,7 +456,7 @@ var CodeTransformer = class {
    * your `start/kernel.ts` file.
    */
   async addMiddlewareToStack(stack, middleware) {
-    const kernelUrl = fileURLToPath2(new URL("./start/kernel.ts", this.#cwd));
+    const kernelUrl = join(this.#cwdPath, "./start/kernel.ts");
     const file = this.project.getSourceFileOrThrow(kernelUrl);
     for (const middlewareEntry of middleware) {
       if (stack === "named") {
@@ -470,7 +480,7 @@ var CodeTransformer = class {
    * Add a new Japa plugin in the `tests/bootstrap.ts` file
    */
   async addJapaPlugin(pluginCall, importDeclarations) {
-    const testBootstrapUrl = fileURLToPath2(new URL("./tests/bootstrap.ts", this.#cwd));
+    const testBootstrapUrl = join(this.#cwdPath, "./tests/bootstrap.ts");
     const file = this.project.getSourceFileOrThrow(testBootstrapUrl);
     this.#addImportDeclarations(file, importDeclarations);
     const pluginsArray = file.getVariableDeclaration("plugins")?.getInitializerIfKind(SyntaxKind2.ArrayLiteralExpression);
@@ -486,7 +496,7 @@ var CodeTransformer = class {
    * Add a new Vite plugin
    */
   async addVitePlugin(pluginCall, importDeclarations) {
-    const viteConfigTsUrl = fileURLToPath2(new URL("./vite.config.ts", this.#cwd));
+    const viteConfigTsUrl = join(this.#cwdPath, "./vite.config.ts");
     const file = this.project.getSourceFile(viteConfigTsUrl);
     if (!file) {
       throw new Error(
@@ -512,7 +522,7 @@ var CodeTransformer = class {
    * inside the `app/policies/main.ts` file.
    */
   async addPolicies(policies) {
-    const kernelUrl = fileURLToPath2(new URL("./app/policies/main.ts", this.#cwd));
+    const kernelUrl = join(this.#cwdPath, "./app/policies/main.ts");
     const file = this.project.getSourceFileOrThrow(kernelUrl);
     for (const policy of policies) {
       this.#addToPoliciesList(file, policy);
@@ -520,8 +530,64 @@ var CodeTransformer = class {
     file.formatText(this.#editorSettings);
     await file.save();
   }
+  /**
+   * Creates an index file that exports an object in which the key is the PascalCase
+   * name of the entity and the value is a dynamic import.
+   *
+   * For example, in case of controllers, the index file will be the list of controller
+   * names pointing a dynamically imported controller file.
+   *
+   * ```ts
+   * export const controllers = {
+   *   Login: () => import('#controllers/login_controller'),
+   *   Login: () => import('#controllers/login_controller'),
+   * }
+   * ```
+   *
+   * @param source
+   * @param outputPath
+   * @param importAlias
+   */
+  async makeEntityIndex(input, output) {
+    const inputs = Array.isArray(input) ? input : [input];
+    const outputPath = join(this.#cwdPath, output.destination);
+    const outputDir = dirname(outputPath);
+    const exportName = output.exportName ?? new StringBuilder(basename(output.destination)).removeExtension().camelCase();
+    debug_default(
+      'creating index for "%s" at destination "%s" using sources %O',
+      exportName,
+      outputPath,
+      inputs
+    );
+    const entries = await Promise.all(
+      inputs.map(async ({ source, importAlias }) => {
+        const sourcePath = join(this.#cwdPath, source);
+        const filesList = await fsReadAll(sourcePath, {
+          filter: isScriptFile,
+          pathType: "absolute"
+        });
+        return filesList.map((filePath) => {
+          const name = new StringBuilder(string.toUnixSlash(relative(sourcePath, filePath))).removeExtension().pascalCase().toString();
+          const importPath = importAlias ? `${importAlias}/${new StringBuilder(string.toUnixSlash(relative(sourcePath, filePath))).removeExtension().toString()}` : string.toUnixSlash(relative(outputDir, filePath));
+          return {
+            name: output.transformName?.(name) ?? name,
+            importPath: output.transformImport?.(importPath) ?? importPath
+          };
+        });
+      })
+    );
+    const outputContents = entries.flat(2).reduce(
+      (result, entry) => {
+        debug_default('adding "%O" to the index', entry);
+        result.push(`  ${entry.name}: () => import('${entry.importPath}'),`);
+        return result;
+      },
+      [`export const ${exportName} = {`]
+    ).concat("}");
+    await mkdir(outputDir, { recursive: true });
+    await writeFile(outputPath, outputContents.join("\n"));
+  }
 };
 export {
   CodeTransformer
 };
-//# sourceMappingURL=main.js.map

package/build/src/code_transformer/rc_file_transformer.d.ts

@@ -1,5 +1,6 @@
-import type { AppEnvironments, RcFile } from '@adonisjs/application/types';
-import { Project } from 'ts-morph';
+import { type Project } from 'ts-morph';
+import { type AssemblerRcFile } from '../types/common.ts';
+declare const ALLOWED_ENVIRONMENTS: readonly ["web", "console", "test", "repl"];
 /**
  * RcFileTransformer is used to transform the `adonisrc.ts` file
  * for adding new commands, providers, meta files etc
@@ -14,11 +15,11 @@ export declare class RcFileTransformer {
     /**
      * Add a new preloaded file to the rcFile
      */
-    addPreloadFile(modulePath: string, environments?: AppEnvironments[]): this;
+    addPreloadFile(modulePath: string, environments?: (typeof ALLOWED_ENVIRONMENTS)[number][]): this;
     /**
      * Add a new provider to the rcFile
      */
-    addProvider(providerPath: string, environments?: AppEnvironments[]): this;
+    addProvider(providerPath: string, environments?: (typeof ALLOWED_ENVIRONMENTS)[number][]): this;
     /**
      * Add a new meta file to the rcFile
      */
@@ -38,9 +39,10 @@ export declare class RcFileTransformer {
     /**
      * Add a new assembler hook
      */
-    addAssemblerHook(type: keyof NonNullable<RcFile['hooks']>, path: string): this;
+    addAssemblerHook(type: keyof Exclude<AssemblerRcFile['hooks'], undefined>, path: string): this;
     /**
      * Save the adonisrc.ts file
      */
     save(): Promise<void>;
 }
+export {};

package/build/src/dev_server.d.ts

@@ -1,24 +1,52 @@
 import type tsStatic from 'typescript';
-import { type Logger } from '@poppinss/cliui';
-import type { DevServerOptions } from './types.js';
+import type { DevServerOptions } from './types/common.ts';
 /**
- * Exposes the API to start the development. Optionally, the watch API can be
- * used to watch for file changes and restart the development server.
+ * Exposes the API to start the development server in HMR, watch or static mode.
  *
- * The Dev server performs the following actions
+ * In HMR mode, the DevServer will exec the "bin/server.ts" file and let hot-hook
+ * manage the changes using hot module reloading.
  *
- * - Assigns a random PORT, when PORT inside .env file is in use.
- * - Uses tsconfig.json file to collect a list of files to watch.
- * - Uses metaFiles from adonisrc.ts file to collect a list of files to watch.
- * - Restart HTTP server on every file change.
+ * 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),
+ * or registered as metaFiles.
  */
 export declare class DevServer {
     #private;
-    constructor(cwd: URL, options: DevServerOptions);
+    cwd: URL;
+    options: DevServerOptions;
+    /**
+     * CLI UI to log colorful messages
+     */
+    ui: {
+        colors: import("@poppinss/colors/types").Colors;
+        logger: import("@poppinss/cliui").Logger;
+        table: (tableOptions?: Partial<import("@poppinss/cliui/types").TableOptions>) => import("@poppinss/cliui").Table;
+        tasks: (tasksOptions?: Partial<import("@poppinss/cliui/types").TaskManagerOptions>) => import("@poppinss/cliui").TaskManager;
+        icons: {
+            tick: string;
+            cross: string;
+            bullet: string;
+            nodejs: string;
+            pointer: string;
+            info: string;
+            warning: string;
+            squareSmallFilled: string;
+        };
+        sticker: () => import("@poppinss/cliui").Instructions;
+        instructions: () => import("@poppinss/cliui").Instructions;
+        switchMode(modeToUse: "raw" | "silent" | "normal"): void;
+        useRenderer(rendererToUse: import("@poppinss/cliui/types").RendererContract): void;
+        useColors(colorsToUse: import("@poppinss/colors/types").Colors): void;
+    };
     /**
-     * Set a custom CLI UI logger
+     * The mode in which the DevServer is running.
      */
-    setLogger(logger: Logger): this;
+    get mode(): "hmr" | "watch" | "static";
+    /**
+     * Script file to start the development server
+     */
+    scriptFile: string;
+    constructor(cwd: URL, options: DevServerOptions);
     /**
      * Add listener to get notified when dev server is
      * closed
@@ -30,13 +58,13 @@ export declare class DevServer {
      */
     onError(callback: (error: any) => any): this;
     /**
-     * Close watchers and running child processes
+     * Close watchers and the running child process
      */
     close(): Promise<void>;
     /**
      * Start the development server
      */
-    start(): Promise<void>;
+    start(ts: typeof tsStatic): Promise<void>;
     /**
      * Start the development server in watch mode
      */

package/build/src/file_system.d.ts

@@ -0,0 +1,60 @@
+import type tsStatic from 'typescript';
+import { type InspectedFile, type AssemblerRcFile } from './types/common.ts';
+/**
+ * Exposes an intutive API to run actions when different kind of files
+ * are changed. The FileSystem is built around the vocabulary used by
+ * AdonisJS. Which includes:
+ *
+ * - Source files: TypeScript, JavaScript, JSON, JSX, TSX files that are included
+ *   inside the "tsconfig.json" file are considered as source files.
+ * - Meta files: Files registered under the "metaFiles" array of "adonisrc.ts" file
+ *   are called meta files.
+ * - Meta restart files: Meta files with "restart: true" enabled are called meta restart
+ *   files.
+ *
+ * Using FileSystem you can register actions to be executed when a file changes in
+ * one of the above categories.
+ */
+export declare class FileSystem {
+    #private;
+    /**
+     * Includes glob patterns extracted from "tsconfig.json" file.
+     * Defaults to: ["**\/*"]
+     */
+    get includes(): string[];
+    /**
+     * Excludes glob patterns extracted from "tsconfig.json" file.
+     *
+     * Defaults to: [
+     *   'node_modules/**',
+     *   'bower_components/**',
+     *   'jspm_packages/**,
+     * ]
+     *
+     * Following patterns are always ignored
+     *
+     * '.git/**', 'coverage/**', '.github/**'
+     */
+    get excludes(): string[];
+    /**
+     * Inspect a relative path to find its source in the project
+     */
+    inspect: (input: string) => InspectedFile | null;
+    /**
+     * Returns true if the directory should be watched. Chokidar sends
+     * absolute unix paths to the ignored callback.
+     *
+     * You must use "shouldWatchFile" method for files and call this method
+     * for directories only.
+     */
+    shouldWatchDirectory: (input: string) => unknown;
+    constructor(cwd: URL | string, tsConfig: tsStatic.ParsedCommandLine, rcFile: AssemblerRcFile);
+    /**
+     * Returns true if the file should be watched. Chokidar sends
+     * absolute unix paths to the ignored callback.
+     *
+     * You must use "shouldWatchDirectory" method for directories and call
+     * this method for files only.
+     */
+    shouldWatchFile(absolutePath: string): boolean;
+}

package/build/src/test_runner.d.ts

@@ -1,6 +1,5 @@
 import type tsStatic from 'typescript';
-import { type Logger } from '@poppinss/cliui';
-import type { TestRunnerOptions } from './types.js';
+import type { TestRunnerOptions } from './types/common.ts';
 /**
  * Exposes the API to run Japa tests and optionally watch for file
  * changes to re-run the tests.
@@ -11,15 +10,40 @@ import type { TestRunnerOptions } from './types.js';
  *    will be re-run.
  *  - Otherwise, all tests will re-run with respect to the initial
  *    filters applied when running the `node ace test` command.
- *
  */
 export declare class TestRunner {
     #private;
-    constructor(cwd: URL, options: TestRunnerOptions);
+    cwd: URL;
+    options: TestRunnerOptions;
     /**
-     * Set a custom CLI UI logger
+     * CLI UI to log colorful messages
      */
-    setLogger(logger: Logger): this;
+    ui: {
+        colors: import("@poppinss/colors/types").Colors;
+        logger: import("@poppinss/cliui").Logger;
+        table: (tableOptions?: Partial<import("@poppinss/cliui/types").TableOptions>) => import("@poppinss/cliui").Table;
+        tasks: (tasksOptions?: Partial<import("@poppinss/cliui/types").TaskManagerOptions>) => import("@poppinss/cliui").TaskManager;
+        icons: {
+            tick: string;
+            cross: string;
+            bullet: string;
+            nodejs: string;
+            pointer: string;
+            info: string;
+            warning: string;
+            squareSmallFilled: string;
+        };
+        sticker: () => import("@poppinss/cliui").Instructions;
+        instructions: () => import("@poppinss/cliui").Instructions;
+        switchMode(modeToUse: "raw" | "silent" | "normal"): void;
+        useRenderer(rendererToUse: import("@poppinss/cliui/types").RendererContract): void;
+        useColors(colorsToUse: import("@poppinss/colors/types").Colors): void;
+    };
+    /**
+     * The script file to run as a child process
+     */
+    scriptFile: string;
+    constructor(cwd: URL, options: TestRunnerOptions);
     /**
      * Add listener to get notified when dev server is
      * closed

package/build/src/types/code_transformer.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Entry to add a middleware to a given middleware stack
+ * via the CodeTransformer
+ */
+export type MiddlewareNode = {
+    /**
+     * If you are adding a named middleware, then you must
+     * define the name.
+     */
+    name?: string;
+    /**
+     * The path to the middleware file
+     *
+     * @example
+     *  `@adonisjs/static/static_middleware`
+     *  `#middlewares/silent_auth.js`
+     */
+    path: string;
+    /**
+     * The position to add the middleware. If `before`
+     * middleware will be added at the first position and
+     * therefore will be run before all others
+     *
+     * @default 'after'
+     */
+    position?: 'before' | 'after';
+};
+/**
+ * Policy node to be added to the list of policies.
+ */
+export type BouncerPolicyNode = {
+    /**
+     * Policy name
+     */
+    name: string;
+    /**
+     * Policy import path
+     */
+    path: string;
+};
+/**
+ * Defines the structure of an environment variable validation
+ * definition
+ */
+export type EnvValidationNode = {
+    /**
+     * Write a leading comment on top of your variables
+     */
+    leadingComment?: string;
+    /**
+     * A key-value pair of env variables and their validation
+     *
+     * @example
+     *  MY_VAR: 'Env.schema.string.optional()'
+     */
+    variables: Record<string, string>;
+};
+/**
+ * The supported package managers for installing packages
+ */
+export type SupportedPackageManager = 'npm' | 'yarn' | 'yarn@berry' | 'pnpm' | 'bun';