@adonisjs/assembler 8.0.0-next.9 → 8.0.0

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 @@
+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,7 @@ export declare function runNode(cwd: string | URL, options: RunScriptOptions): i
     buffer: false;
     stdio: "pipe" | "inherit";
     env: {
-        TZ?: string;
+        TZ?: string | undefined;
         FORCE_COLOR?: string | undefined;
     };
 }>;
@@ -58,7 +62,7 @@ export declare function run(cwd: string | URL, options: Omit<RunScriptOptions, '
     buffer: false;
     stdio: "pipe" | "inherit";
     env: {
-        TZ?: string;
+        TZ?: string | undefined;
         FORCE_COLOR?: string | undefined;
     };
 }>;
@@ -144,7 +148,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

package/build/validator_extractor-Ccio_Ndi.js

@@ -0,0 +1,82 @@
+import { i as isRelative, m as debug_default } from "./virtual_file_system-bGeoWsK-.js";
+import { findImport, inspectClass, inspectClassMethods, inspectMethodArguments, nodeToPlainText, searchValidatorDirectUsage } from "./src/helpers.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import string from "@poppinss/utils/string";
+import { join, relative } from "node:path";
+import { resolve } from "import-meta-resolve";
+var PathsResolver = class {
+	#appRoot;
+	#resolvedPaths = {};
+	#resolver = (specifier, parentPath) => resolve(specifier, parentPath);
+	constructor(appRoot) {
+		this.#appRoot = pathToFileURL(join(appRoot, "index.js")).href;
+	}
+	use(resolver) {
+		this.#resolver = resolver;
+	}
+	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];
+	}
+};
+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) => {
+		return methodNode.find({ rule: { kind: "property_identifier" } })?.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",
+		"$CTX.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);
+	return (await Promise.all(validationCalls.map(async (validationCall) => {
+		if (validationCall.split(".")[0] === 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, fileURLToPath(new URL(importCall.specifier, controllerURL)))) : importCall.specifier,
+				type: importCall.clause.type,
+				value: importCall.clause.value
+			}
+		};
+	}))).filter((value) => !!value);
+}
+export { PathsResolver as n, extractValidators as t };