@adonisjs/assembler 8.0.0-next.9 → 8.0.1

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
@@ -33,6 +32,7 @@ export declare class TestRunner {
         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;
+        steps: () => import("@poppinss/cliui").Steps;
         icons: {
             tick: string;
             cross: string;
@@ -42,6 +42,7 @@ export declare class TestRunner {
             info: string;
             warning: string;
             squareSmallFilled: string;
+            borderVertical: string;
         };
         sticker: () => import("@poppinss/cliui").Instructions;
         instructions: () => import("@poppinss/cliui").Instructions;
@@ -111,7 +112,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

@@ -70,8 +70,8 @@ export type ScannedValidator = {
  *   pattern: '/users',
  *   tokens: [{ val: '/users', old: '/users', type: 0, end: '' }],
  *   request: {
- *     type: 'Infer<typeof createUserValidator>',
- *     imports: ['import { Infer } from "@vinejs/vine/types"']
+ *     type: 'InferInput<typeof createUserValidator>',
+ *     imports: ['import { InferInput } from "@vinejs/vine/types"']
  *   },
  *   response: {
  *     type: 'ReturnType<UsersController["store"]>',
@@ -174,12 +174,12 @@ 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 information for controller-based routes */
+    handler?: {
+        /** The method name to be called on the controller */
+        method: string;
+        /** Dynamic import expression that loads the controller module */
+        importExpression: string | null;
     };
     /** Parsed route tokens for URI construction */
     tokens: {
@@ -189,6 +189,27 @@ export type RoutesListItem = {
         end: string;
     }[];
 };
+/**
+ * A filter function to exclude routes from being processed by the routes scanner.
+ * Return false to filter out (exclude) the route, or true to include it.
+ *
+ * @example
+ * const filterFn: RoutesScannerFilterFn = (route) => {
+ *   // Exclude all admin routes
+ *   if (route.pattern.startsWith('/admin')) {
+ *     return false
+ *   }
+ *
+ *   // Exclude health check routes
+ *   if (route.name === 'health.check') {
+ *     return false
+ *   }
+ *
+ *   // Include all other routes
+ *   return true
+ * }
+ */
+export type RoutesScannerFilterFn = (route: RoutesListItem) => boolean;
 /**
  * Configuration rules accepted by the routes scanner to customize
  * the scanning behavior and override type inference.
@@ -211,11 +232,6 @@ export type RoutesListItem = {
  * }
  */
 export type RoutesScannerRules = {
-    /**
-     * An array of route names or controller+method paths to skip from processing.
-     * Useful for excluding routes that don't need type generation.
-     */
-    skip: string[];
     /**
      * Define custom response types for specific routes by their name
      * or controller+method path. Overrides automatic type inference.

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

@@ -1,3 +1,4 @@
+import { type ImportInfo } from '@poppinss/utils';
 /**
  * Entry to add a middleware to a given middleware stack via the CodeTransformer.
  * Represents middleware configuration for server, router, or named middleware stacks.
@@ -90,6 +91,132 @@ export type EnvValidationNode = {
      */
     variables: Record<string, string>;
 };
+/**
+ * Configuration for creating a new validator file via CodeTransformer.
+ * Represents the structure needed to generate validator files.
+ *
+ * @example
+ * const validator: ValidatorNode = {
+ *   validatorFileName: 'create_user',
+ *   exportName: 'createUserValidator',
+ *   contents: 'export const createUserValidator = vine.compile(...)'
+ * }
+ */
+export type ValidatorNode = {
+    /** The filename for the validator (without extension) */
+    validatorFileName: string;
+    /** The name of the exported validator constant or function */
+    exportName: string;
+    /** The complete file contents including the validator definition */
+    contents: string;
+};
+/**
+ * Configuration for creating a new rate limiter file via CodeTransformer.
+ * Represents the structure needed to generate limiter files.
+ *
+ * @example
+ * const limiter: LimiterNode = {
+ *   limiterFileName: 'api_throttle',
+ *   exportName: 'apiThrottleLimiter',
+ *   contents: 'export const apiThrottleLimiter = limiter.define(...)'
+ * }
+ */
+export type LimiterNode = {
+    /** The filename for the limiter (without extension) */
+    limiterFileName: string;
+    /** The name of the exported limiter constant or function */
+    exportName: string;
+    /** The complete file contents including the limiter definition */
+    contents: string;
+};
+/**
+ * Definition for applying a mixin to a model class.
+ * Mixins extend model functionality by adding methods, properties, or behaviors.
+ *
+ * @example
+ * const mixin: MixinDefinition = {
+ *   name: 'SoftDeletes',
+ *   importPath: '@adonisjs/lucid/mixins/soft_deletes',
+ *   importType: 'named'
+ * }
+ *
+ * @example
+ * const mixinWithArgs: MixinDefinition = {
+ *   name: 'Sluggable',
+ *   args: ['title', '{ strategy: "dbIncrement" }'],
+ *   importPath: '#mixins/sluggable',
+ *   importType: 'default'
+ * }
+ */
+export type MixinDefinition = {
+    /** The name of the mixin function or class */
+    name: string;
+    /** Optional arguments to pass to the mixin function */
+    args?: string[];
+    /** The import path to the mixin module */
+    importPath: string;
+    /** Whether the mixin is exported as named or default export */
+    importType: 'named' | 'default';
+};
+/**
+ * Configuration for adding a new method to an existing controller class.
+ * Used by CodeTransformer to inject methods into controller files.
+ *
+ * @example
+ * const method: ControllerMethodNode = {
+ *   controllerFileName: 'users_controller',
+ *   className: 'UsersController',
+ *   name: 'destroy',
+ *   contents: 'async destroy({ params, response }: HttpContext) { ... }',
+ *   imports: [
+ *     { isType: false, isNamed: true, name: 'HttpContext', path: '@adonisjs/core/http' }
+ *   ]
+ * }
+ */
+export type ControllerMethodNode = {
+    /** The controller filename (without extension) */
+    controllerFileName: string;
+    /** The name of the controller class */
+    className: string;
+    /** The name of the method to add */
+    name: string;
+    /** The complete method implementation including signature and body */
+    contents: string;
+    /** Optional imports needed by the method */
+    imports?: ImportInfo[];
+};
+/**
+ * Configuration for adding hooks to adonisrc.ts file.
+ * Hooks can be defined as thunks (lazy imports) or direct imports.
+ *
+ * @example
+ * // Thunk style (lazy import)
+ * const thunkHook: HookNode = {
+ *   type: 'thunk',
+ *   path: './commands/migrate.js'
+ * }
+ *
+ * @example
+ * // Import style with named export
+ * const importHook: HookNode = {
+ *   type: 'import',
+ *   path: '#hooks/after_build',
+ *   name: 'afterBuildHook'
+ * }
+ */
+export type HookNode = {
+    /** Hook type: thunk creates a lazy import function */
+    type: 'thunk';
+    /** Path to the hook module */
+    path: string;
+} | {
+    /** Hook type: import directly imports the hook */
+    type: 'import';
+    /** Path to the hook module */
+    path: string;
+    /** Optional name of the exported hook (for named exports) */
+    name?: string;
+};
 /**
  * The supported package managers for installing packages and managing lockfiles.
  * Each package manager has specific lockfiles and install commands.

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

@@ -4,6 +4,7 @@ import type StringBuilder from '@poppinss/utils/string_builder';
 import { type AllHooks } from './hooks.ts';
 import { type FileBuffer } from '../file_buffer.ts';
 import { type VirtualFileSystem } from '../virtual_file_system.ts';
+import { type FilterPredicate } from 'fdir';
 /**
  * Recursive file tree structure for representing nested directory hierarchies
  */
@@ -15,6 +16,7 @@ export type RecursiveFileTree = {
  */
 export type VirtualFileSystemOptions = {
     glob?: string[];
+    filter?: FilterPredicate;
 };
 /**
  * Source configuration accepted by the index generator
@@ -22,6 +24,11 @@ export type VirtualFileSystemOptions = {
 export type IndexGeneratorSourceConfig = ({
     exportName: string;
     as: 'barrelFile';
+    /**
+     * Disable the use of lazy imports and instead import the
+     * files using the import expression
+     */
+    disableLazyImports?: boolean;
 } | {
     as: (vfs: VirtualFileSystem, buffer: FileBuffer, config: IndexGeneratorSourceConfig, helpers: {
         toImportPath(filePath: string): string;
@@ -30,10 +37,11 @@ export type IndexGeneratorSourceConfig = ({
     computeBaseName?: (baseName: StringBuilder) => StringBuilder;
     source: string;
     output: string;
-    glob?: string[];
     importAlias?: string;
     removeSuffix?: string;
-};
+    skipSegments?: string[];
+    comment?: string | boolean;
+} & VirtualFileSystemOptions;
 /**
  * Marks a given optional property as required
  *
@@ -338,3 +346,91 @@ export interface ShortcutsManagerOptions {
     /** Callback functions for different shortcut actions */
     callbacks: KeyboardShortcutsCallbacks;
 }
+/**
+ * Message sent from the dev server child process to the parent when the server is ready.
+ * Used for IPC communication to notify when the AdonisJS HTTP server has started.
+ *
+ * @example
+ * const message: AdonisJSServerReadyMessage = {
+ *   isAdonisJS: true,
+ *   environment: 'web',
+ *   port: 3333,
+ *   host: 'localhost',
+ *   duration: [0, 150000000] // [seconds, nanoseconds]
+ * }
+ */
+export type AdonisJSServerReadyMessage = {
+    /** Marker to identify AdonisJS-specific messages */
+    isAdonisJS: true;
+    /** The environment type (always 'web' for HTTP servers) */
+    environment: 'web';
+    /** The port number the server is listening on */
+    port: number;
+    /** The host address the server is bound to */
+    host: string;
+    /** Optional server startup duration as [seconds, nanoseconds] tuple */
+    duration?: [number, number];
+};
+/**
+ * Message sent from the dev server child process when routes are committed.
+ * Contains the file location where routes are defined.
+ *
+ * @example
+ * const message: AdonisJSRoutesSharedMessage = {
+ *   isAdonisJS: true,
+ *   routesFileLocation: '/project/start/routes.ts'
+ * }
+ */
+export type AdonisJSRoutesSharedMessage = {
+    /** Marker to identify AdonisJS-specific messages */
+    isAdonisJS: true;
+    /** Absolute path to the routes definition file */
+    routesFileLocation: string;
+};
+/**
+ * Messages sent by the hot-hook module for HMR (Hot Module Replacement) communication.
+ * These messages notify the dev server about file system changes and module invalidations.
+ *
+ * @example
+ * // Full reload required
+ * const fullReload: HotHookMessage = {
+ *   type: 'hot-hook:full-reload',
+ *   path: 'app/middleware/auth.ts',
+ *   shouldBeReloadable: false
+ * }
+ *
+ * @example
+ * // Modules invalidated (can be hot-reloaded)
+ * const invalidated: HotHookMessage = {
+ *   type: 'hot-hook:invalidated',
+ *   paths: ['app/controllers/users_controller.ts', 'app/models/user.ts']
+ * }
+ *
+ * @example
+ * // File changed notification
+ * const fileChanged: HotHookMessage = {
+ *   type: 'hot-hook:file-changed',
+ *   path: 'config/database.ts',
+ *   action: 'change'
+ * }
+ */
+export type HotHookMessage = {
+    /** Message type indicating a full server reload is required */
+    type: 'hot-hook:full-reload';
+    /** Path to the file that triggered the full reload */
+    path: string;
+    /** Whether the file should be hot-reloadable but isn't */
+    shouldBeReloadable?: boolean;
+} | {
+    /** Message type indicating modules have been invalidated */
+    type: 'hot-hook:invalidated';
+    /** Array of module paths that were invalidated */
+    paths: string[];
+} | {
+    /** Message type indicating a file has changed */
+    type: 'hot-hook:file-changed';
+    /** Path to the file that changed */
+    path: string;
+    /** The type of file system change */
+    action: 'change' | 'add' | 'unlink';
+};

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

@@ -6,6 +6,7 @@ import { type TestRunner } from '../test_runner.ts';
 import { type RoutesListItem } from './code_scanners.ts';
 import { type IndexGenerator } from '../index_generator/main.ts';
 import { type RoutesScanner } from '../code_scanners/routes_scanner/main.ts';
+import type Hooks from '@poppinss/hooks';
 /**
  * Defines a hook that can be either a lazy import or an object with a run method.
  * This type provides flexibility in how hooks are defined and imported, supporting
@@ -45,7 +46,9 @@ export type CommonHooks = {
      *
      * @param parent - The parent instance (DevServer, TestRunner, or Bundler)
      */
-    init: DefineHook<(parent: DevServer | TestRunner | Bundler, indexGenerator: IndexGenerator) => AsyncOrSync<void>>[];
+    init: DefineHook<(parent: DevServer | TestRunner | Bundler, hooks: Hooks<{
+        [P in keyof AllHooks]: [HookParams<P>, HookParams<P>];
+    }>, indexGenerator: IndexGenerator) => AsyncOrSync<void>>[];
 };
 /**
  * Hooks executed by the dev server around the router.

package/build/src/types/main.js

@@ -0,0 +1,2 @@
+import "../../chunk-DF48asd8.js";
+export {};

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,6 @@ export declare function runNode(cwd: string | URL, options: RunScriptOptions): i
     buffer: false;
     stdio: "pipe" | "inherit";
     env: {
-        TZ?: string;
         FORCE_COLOR?: string | undefined;
     };
 }>;
@@ -58,7 +61,6 @@ export declare function run(cwd: string | URL, options: Omit<RunScriptOptions, '
     buffer: false;
     stdio: "pipe" | "inherit";
     env: {
-        TZ?: string;
         FORCE_COLOR?: string | undefined;
     };
 }>;
@@ -144,7 +146,9 @@ export declare function isRelative(pathValue: string): boolean;
  * @param names - Array of hook names to load
  * @returns Promise resolving to configured Hooks instance
  */
-export declare function loadHooks<K extends keyof AllHooks>(rcFileHooks: Partial<AllHooks> | undefined, names: K[]): Promise<Hooks<{ [P in K]: [HookParams<P>, HookParams<P>]; }>>;
+export declare function loadHooks<K extends keyof AllHooks>(rcFileHooks: Partial<AllHooks> | undefined, names: K[]): Promise<Hooks<{
+    [P in K]: [HookParams<P>, HookParams<P>];
+}>>;
 /**
  * Wraps a function inside another function that throttles the concurrent
  * executions of a function. If the function is called too quickly, then

package/build/src/virtual_file_system.d.ts

@@ -65,7 +65,7 @@ export declare class VirtualFileSystem {
      */
     asTree(options?: {
         transformKey?: (key: string) => string;
-        transformValue?: (filePath: string) => string;
+        transformValue?: (filePath: string, key: string) => string;
     }): RecursiveFileTree;
     /**
      * Add a new file to the virtual file system. File is only added when it