@adonisjs/core 7.0.0-next.0 → 7.0.0-next.2

package/build/commands/make/view.d.ts

@@ -1,14 +1,37 @@
 import { BaseCommand } from '../../modules/ace/main.ts';
 /**
- * Make a new EdgeJS template file
+ * Command to create a new Edge.js template file.
+ * Edge templates are used for rendering HTML views in your web application,
+ * supporting layouts, partials, components, and template inheritance.
+ *
+ * @example
+ * ```
+ * ace make:view home
+ * ace make:view users/profile
+ * ace make:view components/navbar
+ * ace make:view layouts/app
+ * ```
  */
 export default class MakeView extends BaseCommand {
+    /**
+     * The command name
+     */
     static commandName: string;
+    /**
+     * The command description
+     */
     static description: string;
+    /**
+     * Name of the template file to create
+     */
     name: string;
     /**
-     * The stub to use for generating the template
+     * The stub template file to use for generating the Edge template
      */
     protected stubPath: string;
+    /**
+     * Execute the command to create a new Edge.js template file.
+     * Generates the template file in the views directory.
+     */
     run(): Promise<void>;
 }

package/build/commands/make/view.js

@@ -15,15 +15,35 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { stubsRoot } from "../../stubs/main.js";
 import { args, BaseCommand } from "../../modules/ace/main.js";
 /**
- * Make a new EdgeJS template file
+ * Command to create a new Edge.js template file.
+ * Edge templates are used for rendering HTML views in your web application,
+ * supporting layouts, partials, components, and template inheritance.
+ *
+ * @example
+ * ```
+ * ace make:view home
+ * ace make:view users/profile
+ * ace make:view components/navbar
+ * ace make:view layouts/app
+ * ```
  */
 export default class MakeView extends BaseCommand {
+    /**
+     * The command name
+     */
     static commandName = 'make:view';
+    /**
+     * The command description
+     */
     static description = 'Create a new Edge.js template file';
     /**
-     * The stub to use for generating the template
+     * The stub template file to use for generating the Edge template
      */
     stubPath = 'make/view/main.stub';
+    /**
+     * Execute the command to create a new Edge.js template file.
+     * Generates the template file in the views directory.
+     */
     async run() {
         const codemods = await this.createCodemods();
         await codemods.makeUsingStub(stubsRoot, this.stubPath, {

package/build/commands/repl.d.ts

@@ -1,14 +1,34 @@
 import { BaseCommand } from '../modules/ace/main.ts';
 import { type CommandOptions } from '../types/ace.ts';
 /**
- * The ReplCommand class is used to start the Repl server
+ * Command to start an interactive REPL (Read-Eval-Print Loop) session for AdonisJS.
+ * The REPL provides a command-line interface where you can execute JavaScript code
+ * in the context of your AdonisJS application, allowing you to interact with models,
+ * services, and other application components in real-time.
+ *
+ * @example
+ * ```
+ * ace repl
+ * ```
  */
 export default class ReplCommand extends BaseCommand {
+    /**
+     * The command name
+     */
     static commandName: string;
+    /**
+     * The command description
+     */
     static description: string;
+    /**
+     * Command options configuration.
+     * Requires the application to be started and keeps the process alive.
+     */
     static options: CommandOptions;
     /**
-     * Starts the REPL server process
+     * Execute the command to start the REPL server.
+     * Creates a REPL instance from the container and sets up an exit handler
+     * that properly terminates the application when the REPL session ends.
      */
     run(): Promise<void>;
 }

package/build/commands/repl.js

@@ -8,17 +8,37 @@
  */
 import { BaseCommand } from "../modules/ace/main.js";
 /**
- * The ReplCommand class is used to start the Repl server
+ * Command to start an interactive REPL (Read-Eval-Print Loop) session for AdonisJS.
+ * The REPL provides a command-line interface where you can execute JavaScript code
+ * in the context of your AdonisJS application, allowing you to interact with models,
+ * services, and other application components in real-time.
+ *
+ * @example
+ * ```
+ * ace repl
+ * ```
  */
 export default class ReplCommand extends BaseCommand {
+    /**
+     * The command name
+     */
     static commandName = 'repl';
+    /**
+     * The command description
+     */
     static description = 'Start a new REPL session';
+    /**
+     * Command options configuration.
+     * Requires the application to be started and keeps the process alive.
+     */
     static options = {
         startApp: true,
         staysAlive: true,
     };
     /**
-     * Starts the REPL server process
+     * Execute the command to start the REPL server.
+     * Creates a REPL instance from the container and sets up an exit handler
+     * that properly terminates the application when the REPL session ends.
      */
     async run() {
         const repl = await this.app.container.make('repl');

package/build/commands/serve.d.ts

@@ -5,17 +5,53 @@ import { BaseCommand } from '../modules/ace/main.ts';
  * Serve command is used to run the AdonisJS HTTP server during development. The
  * command under the hood runs the "bin/server.ts" file and watches for file
  * system changes
+ *
+ * @example
+ * ```
+ * ace serve
+ * ace serve --watch
+ * ace serve --hmr
+ * ace serve --poll
+ * ace serve --no-clear
+ * ```
  */
 export default class Serve extends BaseCommand {
     #private;
+    /**
+     * The command name
+     */
     static commandName: string;
+    /**
+     * The command description
+     */
     static description: string;
+    /**
+     * Help text for the command
+     */
     static help: string[];
+    /**
+     * Command options configuration
+     */
     static options: CommandOptions;
+    /**
+     * The development server instance
+     */
     devServer: DevServer;
+    /**
+     * Start the server with HMR support
+     */
     hmr?: boolean;
+    /**
+     * Watch filesystem and restart the HTTP server on file change
+     */
     watch?: boolean;
+    /**
+     * Use polling to detect filesystem changes
+     */
     poll?: boolean;
+    /**
+     * Clear the terminal for new logs after file change
+     */
     clear?: boolean;
     /**
      * Runs the HTTP server

package/build/commands/serve.js

@@ -18,10 +18,28 @@ import { importAssembler, importTypeScript } from "../src/utils.js";
  * Serve command is used to run the AdonisJS HTTP server during development. The
  * command under the hood runs the "bin/server.ts" file and watches for file
  * system changes
+ *
+ * @example
+ * ```
+ * ace serve
+ * ace serve --watch
+ * ace serve --hmr
+ * ace serve --poll
+ * ace serve --no-clear
+ * ```
  */
 export default class Serve extends BaseCommand {
+    /**
+     * The command name
+     */
     static commandName = 'serve';
+    /**
+     * The command description
+     */
     static description = 'Start the development HTTP server along with the file watcher to perform restarts on file change';
+    /**
+     * Help text for the command
+     */
     static help = [
         'Start the development server with file watcher using the following command.',
         '```',
@@ -39,11 +57,16 @@ export default class Serve extends BaseCommand {
         '{{ binaryName }} serve --assets-args="--debug --base=/public"',
         '```',
     ];
+    /**
+     * Command options configuration
+     */
     static options = {
         staysAlive: true,
     };
     /**
      * Log a development dependency is missing
+     *
+     * @param dependency - The name of the missing dependency
      */
     #logMissingDevelopmentDependency(dependency) {
         this.logger.error([

package/build/commands/test.d.ts

@@ -2,29 +2,92 @@ import type { TestRunner } from '@adonisjs/assembler';
 import type { CommandOptions } from '../types/ace.ts';
 import { BaseCommand } from '../modules/ace/main.ts';
 /**
- * Test command is used to run tests with optional file watcher. Under the
- * hood, we run "bin/test.js" file.
+ * Command to run application tests using the Japa test runner.
+ * Supports filtering tests by suites, files, tags, groups, and individual tests.
+ * Can run in watch mode to automatically re-run tests when files change.
+ *
+ * @example
+ * ```
+ * ace test
+ * ace test unit integration
+ * ace test --watch
+ * ace test --files=user.spec.ts
+ * ace test --tags=slow --groups="User tests"
+ * ace test --reporters=spec,dot
+ * ace test --timeout=5000 --retries=2
+ * ```
  */
 export default class Test extends BaseCommand {
     #private;
+    /**
+     * The command name
+     */
     static commandName: string;
+    /**
+     * The command description
+     */
     static description: string;
+    /**
+     * Command options configuration.
+     * Allows unknown flags to be passed to Japa and keeps the process alive.
+     */
     static options: CommandOptions;
+    /**
+     * The test runner instance from the assembler package
+     */
     testsRunner: TestRunner;
+    /**
+     * Test suite names to run. When provided, only tests from the specified suites will be executed
+     */
     suites?: string[];
+    /**
+     * Filter tests by filename patterns
+     */
     files?: string[];
+    /**
+     * Filter tests by tags
+     */
     tags?: string[];
+    /**
+     * Filter tests by parent group title
+     */
     groups?: string[];
+    /**
+     * Filter tests by test title
+     */
     tests?: string[];
+    /**
+     * Specify one or more test reporters to use for output formatting
+     */
     reporters?: string[];
+    /**
+     * Enable watch mode to automatically re-run tests when files change
+     */
     watch?: boolean;
+    /**
+     * Use polling instead of native filesystem events to detect file changes
+     */
     poll?: boolean;
+    /**
+     * Default timeout in milliseconds for all tests
+     */
     timeout?: number;
+    /**
+     * Default number of retries for failed tests
+     */
     retries?: number;
+    /**
+     * Execute only tests that failed during the last run
+     */
     failed?: boolean;
+    /**
+     * Clear the terminal for new logs after file change in watch mode
+     */
     clear?: boolean;
     /**
-     * Runs tests
+     * Execute the test command. Sets up the test runner with all configured options
+     * and filters, then runs tests either once or in watch mode. Handles missing
+     * dependencies and properly configures the test environment.
      */
     run(): Promise<void>;
 }

package/build/commands/test.js

@@ -15,18 +15,43 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { BaseCommand, flags, args } from "../modules/ace/main.js";
 import { importAssembler, importTypeScript } from "../src/utils.js";
 /**
- * Test command is used to run tests with optional file watcher. Under the
- * hood, we run "bin/test.js" file.
+ * Command to run application tests using the Japa test runner.
+ * Supports filtering tests by suites, files, tags, groups, and individual tests.
+ * Can run in watch mode to automatically re-run tests when files change.
+ *
+ * @example
+ * ```
+ * ace test
+ * ace test unit integration
+ * ace test --watch
+ * ace test --files=user.spec.ts
+ * ace test --tags=slow --groups="User tests"
+ * ace test --reporters=spec,dot
+ * ace test --timeout=5000 --retries=2
+ * ```
  */
 export default class Test extends BaseCommand {
+    /**
+     * The command name
+     */
     static commandName = 'test';
+    /**
+     * The command description
+     */
     static description = 'Run tests along with the file watcher to re-run tests on file change';
+    /**
+     * Command options configuration.
+     * Allows unknown flags to be passed to Japa and keeps the process alive.
+     */
     static options = {
         allowUnknownFlags: true,
         staysAlive: true,
     };
     /**
-     * Log a development dependency is missing
+     * Log an error message when a required development dependency is missing.
+     * Provides helpful instructions for resolving the issue.
+     *
+     * @param dependency - The name of the missing dependency package
      */
     #logMissingDevelopmentDependency(dependency) {
         this.logger.error([
@@ -38,7 +63,10 @@ export default class Test extends BaseCommand {
         ].join('\n'));
     }
     /**
-     * Collection of unknown flags to pass to Japa
+     * Collect unknown flags and format them to pass to the Japa test runner.
+     * Handles boolean flags, arrays, and single values appropriately.
+     *
+     * @returns Array of formatted command-line arguments for Japa
      */
     #getPassthroughFlags() {
         return this.parsed.unknownFlags
@@ -61,7 +89,9 @@ export default class Test extends BaseCommand {
             .flat(2);
     }
     /**
-     * Runs tests
+     * Execute the test command. Sets up the test runner with all configured options
+     * and filters, then runs tests either once or in watch mode. Handles missing
+     * dependencies and properly configures the test environment.
      */
     async run() {
         process.env.NODE_ENV = 'test';

package/build/modules/ace/codemods.js

@@ -308,8 +308,16 @@ export class Codemods extends EventEmitter {
         const transformer = await this.#getCodeTransformer();
         const appPath = this.#app.makePath();
         const colors = this.#cliLogger.getColors();
-        const devDependencies = packages.filter((pkg) => pkg.isDevDependency).map(({ name }) => name);
-        const dependencies = packages.filter((pkg) => !pkg.isDevDependency).map(({ name }) => name);
+        const devDependencies = packages
+            .filter((pkg) => pkg.isDevDependency)
+            .map(({ name }) => {
+            return name.startsWith('@adonisjs/') ? `${name}@next` : name;
+        });
+        const dependencies = packages
+            .filter((pkg) => !pkg.isDevDependency)
+            .map(({ name }) => {
+            return name.startsWith('@adonisjs/') ? `${name}@next` : name;
+        });
         if (!transformer) {
             this.#cliLogger.warning('Cannot install packages. Install "@adonisjs/assembler" or manually install following packages');
             this.#cliLogger.log(`devDependencies: ${devDependencies.join(',')}`);

package/build/modules/ace/commands.d.ts

@@ -99,7 +99,6 @@ export declare class ListCommand extends AceListCommand implements BaseCommand {
      * This method provides access to AST-based code transformations.
      */
     createCodemods(): Promise<import("./codemods.js").Codemods>;
-    execCommand(): Promise<any>;
     /**
      * Terminate the app. A command should prefer calling this method
      * over the "app.terminate", because this method only triggers

package/build/modules/ace/commands.js

@@ -143,9 +143,6 @@ export class ListCommand extends AceListCommand {
         const { Codemods } = await import('./codemods.js');
         return new Codemods(this.app, this.logger);
     }
-    async execCommand() {
-        return this.exec();
-    }
     /**
      * Terminate the app. A command should prefer calling this method
      * over the "app.terminate", because this method only triggers

package/build/providers/app_provider.d.ts

@@ -1,12 +1,12 @@
 import { Router } from '../modules/http/main.ts';
-import { type TransformFn } from '../types/transformers.ts';
+import { type SerializeFn } from '../types/transformers.ts';
 import type { ApplicationService } from '../src/types.ts';
 /**
  * Extend HTTP request class with the transform method
  */
 declare module '@adonisjs/core/http' {
     interface HttpContext {
-        transform: TransformFn;
+        serialize: SerializeFn;
     }
 }
 /**

package/build/providers/app_provider.js

@@ -16,7 +16,7 @@ import { HttpContext } from "../modules/http/main.js";
 import { Encryption } from "../modules/encryption.js";
 import { Router, Server } from "../modules/http/main.js";
 import { BaseEvent, Emitter } from "../modules/events.js";
-import { transform } from "../modules/transformers/main.js";
+import { serialize } from "../modules/transformers/main.js";
 import BodyParserMiddleware from "../modules/bodyparser/bodyparser_middleware.js";
 /**
  * The Application Service provider registers all the baseline
@@ -337,8 +337,8 @@ export default class AppServiceProvider {
      */
     async boot() {
         BaseEvent.useEmitter(await this.app.container.make('emitter'));
-        HttpContext.macro('transform', function (data, transformer, variant) {
-            return transform(data, transformer, variant, this.containerResolver);
+        HttpContext.instanceProperty('serialize', function (...args) {
+            return serialize(...args);
         });
     }
     /**

package/build/providers/edge_provider.js

@@ -71,6 +71,7 @@ export default class EdgeServiceProvider {
         edge.configure({ cache: app.inProduction });
         /**
          * Define Edge global helpers
+         * @deprecated
          */
         edge.global('route', function (...args) {
             return router.makeUrl(...args);
@@ -80,6 +81,15 @@ export default class EdgeServiceProvider {
         });
         edge.global('app', app);
         edge.global('config', edgeConfigResolver);
+        /**
+         * Route helpers
+         */
+        edge.global('urlFor', function (...args) {
+            return router.urlBuilder.urlFor(...args);
+        });
+        edge.global('signedUrlFor', function (...args) {
+            return router.urlBuilder.signedUrlFor(...args);
+        });
         /**
          * Creating a isolated instance of edge renderer
          */

package/build/src/assembler_hooks/index_entities.d.ts

@@ -1,26 +1,10 @@
 import { type IndexEntitiesConfig } from '../types.ts';
-import { type CommonHooks } from '@adonisjs/assembler/types';
 /**
  * Configures the IndexGenerator to create barrel files for "controllers", "events",
  * and "listeners". This function is used as an assembler hook to automatically generate
  * index files that export all modules from specified directories.
  *
  * @param {IndexEntitiesConfig} entities - Configuration object for entities indexing
- * @param {object} [entities.events] - Configuration for events indexing
- * @param {boolean} [entities.events.enabled=true] - Whether to enable events indexing
- * @param {string} [entities.events.source='app/events'] - Source directory for events
- * @param {string} [entities.events.importAlias='#events'] - Import alias for events
- * @param {string} [entities.events.glob] - Glob pattern for matching event files
- * @param {object} [entities.listeners] - Configuration for listeners indexing
- * @param {boolean} [entities.listeners.enabled=true] - Whether to enable listeners indexing
- * @param {string} [entities.listeners.source='app/listeners'] - Source directory for listeners
- * @param {string} [entities.listeners.importAlias='#listeners'] - Import alias for listeners
- * @param {string} [entities.listeners.glob] - Glob pattern for matching listener files
- * @param {object} [entities.controllers] - Configuration for controllers indexing
- * @param {boolean} [entities.controllers.enabled=true] - Whether to enable controllers indexing
- * @param {string} [entities.controllers.source='app/controllers'] - Source directory for controllers
- * @param {string} [entities.controllers.importAlias='#controllers'] - Import alias for controllers
- * @param {string} [entities.controllers.glob] - Glob pattern for matching controller files
  *
  * @example
  * // Basic usage with default configuration
@@ -48,4 +32,6 @@ import { type CommonHooks } from '@adonisjs/assembler/types';
  *   }
  * })
  */
-export declare function indexEntities(entities?: IndexEntitiesConfig): CommonHooks['init'][number];
+export declare function indexEntities(entities?: IndexEntitiesConfig): {
+    run(_: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner | import("@adonisjs/assembler").Bundler, indexGenerator: import("@adonisjs/assembler/index_generator").IndexGenerator): void;
+};

package/build/src/assembler_hooks/index_entities.js

@@ -6,27 +6,14 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+import stringHelpers from "../helpers/string.js";
+import { outputTransformerDataObjects } from "../utils.js";
 /**
  * Configures the IndexGenerator to create barrel files for "controllers", "events",
  * and "listeners". This function is used as an assembler hook to automatically generate
  * index files that export all modules from specified directories.
  *
  * @param {IndexEntitiesConfig} entities - Configuration object for entities indexing
- * @param {object} [entities.events] - Configuration for events indexing
- * @param {boolean} [entities.events.enabled=true] - Whether to enable events indexing
- * @param {string} [entities.events.source='app/events'] - Source directory for events
- * @param {string} [entities.events.importAlias='#events'] - Import alias for events
- * @param {string} [entities.events.glob] - Glob pattern for matching event files
- * @param {object} [entities.listeners] - Configuration for listeners indexing
- * @param {boolean} [entities.listeners.enabled=true] - Whether to enable listeners indexing
- * @param {string} [entities.listeners.source='app/listeners'] - Source directory for listeners
- * @param {string} [entities.listeners.importAlias='#listeners'] - Import alias for listeners
- * @param {string} [entities.listeners.glob] - Glob pattern for matching listener files
- * @param {object} [entities.controllers] - Configuration for controllers indexing
- * @param {boolean} [entities.controllers.enabled=true] - Whether to enable controllers indexing
- * @param {string} [entities.controllers.source='app/controllers'] - Source directory for controllers
- * @param {string} [entities.controllers.importAlias='#controllers'] - Import alias for controllers
- * @param {string} [entities.controllers.glob] - Glob pattern for matching controller files
  *
  * @example
  * // Basic usage with default configuration
@@ -58,11 +45,13 @@ export function indexEntities(entities = {}) {
     const events = Object.assign({ enabled: true, source: 'app/events', importAlias: '#events' }, entities.events);
     const listeners = Object.assign({ enabled: true, source: 'app/listeners', importAlias: '#listeners' }, entities.listeners);
     const controllers = Object.assign({ enabled: true, source: 'app/controllers', importAlias: '#controllers' }, entities.controllers);
+    const transformers = Object.assign({ enabled: false, source: 'app/transformers', importAlias: '#transformers' }, entities.transformers);
     return {
         run(_, indexGenerator) {
             if (events.enabled) {
                 indexGenerator.add('events', {
                     source: events.source,
+                    disableLazyImports: true,
                     glob: events.glob,
                     as: 'barrelFile',
                     exportName: 'events',
@@ -91,6 +80,28 @@ export function indexEntities(entities = {}) {
                     output: '.adonisjs/server/controllers.ts',
                 });
             }
+            if (transformers.enabled) {
+                indexGenerator.add('transformers', {
+                    source: transformers.source,
+                    glob: transformers.glob,
+                    as(vfs, buffer, __, helpers) {
+                        const transformersList = vfs.asTree({
+                            transformKey(key) {
+                                const segments = key.split('/');
+                                const baseName = segments.pop();
+                                return [
+                                    ...segments.map((segment) => stringHelpers.pascalCase(segment)),
+                                    stringHelpers.create(baseName).removeSuffix('transformer').pascalCase(),
+                                ].join('/');
+                            },
+                            transformValue: helpers.toImportPath,
+                        });
+                        outputTransformerDataObjects(transformersList, buffer);
+                    },
+                    importAlias: transformers.importAlias,
+                    output: '.adonisjs/client/data.d.ts',
+                });
+            }
         },
     };
 }

package/build/src/helpers/string.js

@@ -34,6 +34,12 @@ const stringHelpers = {
     create(value) {
         return new StringBuilder(value);
     },
+    /**
+     * Formats Node.js hrtime output into a human-readable string.
+     *
+     * @param time - Tuple of [seconds, nanoseconds] from process.hrtime()
+     * @param options - Formatting options for output style and precision
+     */
     prettyHrTime(time, options) {
         return prettyHrTime(time, options);
     },

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

@@ -104,6 +104,7 @@ declare const types: {
         urlInstance: typeof import("@sindresorhus/is").isUrlInstance;
         urlSearchParams: typeof import("@sindresorhus/is").isUrlSearchParams;
         urlString: typeof import("@sindresorhus/is").isUrlString;
+        optional: typeof import("@sindresorhus/is").isOptional;
         validDate: typeof import("@sindresorhus/is").isValidDate;
         validLength: typeof import("@sindresorhus/is").isValidLength;
         weakMap: typeof import("@sindresorhus/is").isWeakMap;

package/build/src/types.d.ts

@@ -372,4 +372,10 @@ export type IndexEntitiesConfig = {
         /** Glob patterns for matching event files */
         glob?: string[];
     };
+    transformers?: {
+        enabled?: boolean;
+        source?: string;
+        importAlias?: string;
+        glob?: string[];
+    };
 };